{"matchId":"28523522","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-05-04T14:55:58Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"684:12854:6:-:0;;;;;;;;;;;;-1:-1:-1;936:32:0;719:10:4;936:18:0;:32::i;:::-;996:7:2;:15;;-1:-1:-1;;;;996:15:2;;;684:12854:6;;1501:153:1;1590:13;1583:20;;-1:-1:-1;;;;;;1583:20:1;;;1613:34;1638:8;1613:24;:34::i;:::-;1501:153;:::o;2426:187:0:-;2499:16;2518:6;;-1:-1:-1;;;;;2534:17:0;;;-1:-1:-1;;;;;;2534:17:0;;;;;;2566:40;;2518:6;;;;;;;2566:40;;2499:16;2566:40;2489:124;2426:187;:::o;684:12854:6:-;;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220d310e3742de0aa07d448269423afcb0d444db00c4aefea661f286a52957471f364736f6c634300081c0033","offset":8783}},"transformations":[],"transformationValues":{}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"684:12854:6:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1540:182;;;;;;;;;;-1:-1:-1;1540:182:6;;;;;:::i;:::-;;:::i;:::-;;1928:83;;;;;;;;;;-1:-1:-1;1928:83:6;;;;;:::i;:::-;;:::i;892:26::-;;;;;;;;;;-1:-1:-1;892:26:6;;;;-1:-1:-1;;;;;892:26:6;;;;;;-1:-1:-1;;;;;1008:32:11;;;990:51;;978:2;963:18;892:26:6;;;;;;;;1780:97;;;;;;;;;;-1:-1:-1;1780:97:6;;;;;:::i;:::-;;:::i;2446:74::-;;;;;;;;;;;;;:::i;924:19::-;;;;;;;;;;-1:-1:-1;924:19:6;;;;-1:-1:-1;;;;;924:19:6;;;12942:523;;;;;;:::i;:::-;;:::i;:::-;;;1789:25:11;;;1777:2;1762:18;12942:523:6;1643:177:11;1293:188:6;;;;;;;;;;-1:-1:-1;1293:188:6;;;;;:::i;:::-;;:::i;1615:84:2:-;;;;;;;;;;-1:-1:-1;1685:7:2;;-1:-1:-1;;;1685:7:2;;;;1615:84;;;1990:14:11;;1983:22;1965:41;;1953:2;1938:18;1615:84:2;1825:187:11;2802:331:6;;;;;;;;;;-1:-1:-1;2802:331:6;;;;;:::i;:::-;;:::i;788:47::-;;;;;;;;;;-1:-1:-1;788:47:6;;;;;:::i;:::-;;;;;;;;;;;;;;;;1824:101:0;;;;;;;;;;;;;:::i;1734:212:1:-;;;;;;;;;;;;;:::i;12325:552:6:-;;;;;;:::i;:::-;;:::i;:::-;;;;2842:25:11;;;2898:2;2883:18;;2876:34;;;;2815:18;12325:552:6;2668:248:11;2325:73:6;;;;;;;;;;;;;:::i;1201:85:0:-;;;;;;;;;;-1:-1:-1;1247:7:0;1273:6;-1:-1:-1;;;;;1273:6:0;1201:85;;2066:213:6;;;;;;;;;;-1:-1:-1;2066:213:6;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;841:45::-;;;;;;;;;;-1:-1:-1;841:45:6;;;;;:::i;:::-;;;;;;;;;;;;;;;;3183:310;;;;;;;;;;-1:-1:-1;3183:310:6;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;2569:180::-;;;;;;;;;;-1:-1:-1;2569:180:6;;;;;:::i;:::-;;:::i;847:99:1:-;;;;;;;;;;-1:-1:-1;926:13:1;;-1:-1:-1;;;;;926:13:1;847:99;;1139:178;;;;;;;;;;-1:-1:-1;1139:178:1;;;;;:::i;:::-;;:::i;1540:182:6:-;1094:13:0;:11;:13::i;:::-;-1:-1:-1;;;;;1625:21:6;::::1;;::::0;;;:13:::1;:21;::::0;;;;;;;;:29;;-1:-1:-1;;1625:29:6::1;::::0;::::1;;::::0;;::::1;::::0;;;1670:45;;6460:51:11;;;6527:18;;;6520:50;1689:10:6::1;::::0;1670:45:::1;::::0;6433:18:11;1670:45:6::1;;;;;;;;1540:182:::0;;:::o;1928:83::-;1094:13:0;:11;:13::i;:::-;1992:4:6::1;:12:::0;;-1:-1:-1;;;;;;1992:12:6::1;-1:-1:-1::0;;;;;1992:12:6;;;::::1;::::0;;;::::1;::::0;;1928:83::o;1780:97::-;1094:13:0;:11;:13::i;:::-;1851:11:6::1;:19:::0;;-1:-1:-1;;;;;;1851:19:6::1;-1:-1:-1::0;;;;;1851:19:6;;;::::1;::::0;;;::::1;::::0;;1780:97::o;2446:74::-;1094:13:0;:11;:13::i;:::-;1486:16:2::1;:14;:16::i;:::-;2503:10:6::2;:8;:10::i;:::-;2446:74::o:0;12942:523::-;13032:17;1239:19:2;:17;:19::i;:::-;13061:24:6::1;13088:19;:17;:19::i;:::-;13144:25;::::0;::::1;::::0;13061:46;;-1:-1:-1;13117:24:6::1;13201:32;13061:46:::0;13201:22:::1;:32::i;:::-;13179:54;;13243:34;13280:45;13303:8;13313:11;13280:22;:45::i;:::-;13243:82;;13335:52;13350:8;13360:26;13335:14;:52::i;:::-;13413:45;13418:8;13428:11;13441:16;13413:4;:45::i;:::-;-1:-1:-1::0;13397:61:6;12942:523;-1:-1:-1;;;;;;;12942:523:6:o;1293:188::-;1094:13:0;:11;:13::i;:::-;-1:-1:-1;;;;;1380:23:6;::::1;;::::0;;;:15:::1;:23;::::0;;;;;;;;:31;;-1:-1:-1;;1380:31:6::1;::::0;::::1;;::::0;;::::1;::::0;;;1427:47;;6460:51:11;;;6527:18;;;6520:50;1448:10:6::1;::::0;1427:47:::1;::::0;6433:18:11;1427:47:6::1;6292:284:11::0;2802:331:6;1150:10;1136:25;;;;:13;:25;;;;;;;;1131:84;;1184:20;;-1:-1:-1;;;1184:20:6;;;;;;;;;;;1131:84;2905:9:::1;2900:227;2920:25:::0;;::::1;2900:227;;;2963:94;3003:14;;3018:1;3003:17;;;;;;;:::i;:::-;;;;;;:27;;;;;;;;;;:::i;:::-;3032:14;;3047:1;3032:17;;;;;;;:::i;:::-;;;;;;:24;;;2963:14;;2978:1;2963:17;;;;;;;:::i;:::-;:30;::::0;::::1;:17;::::0;;::::1;;:30:::0;;::::1;::::0;-1:-1:-1;2963:30:6::1;:::i;:::-;-1:-1:-1::0;;;;;2963:39:6::1;::::0;:94;:39:::1;:94::i;:::-;3099:3;;2900:227;;;;2802:331:::0;;:::o;1824:101:0:-;1094:13;:11;:13::i;:::-;1888:30:::1;1915:1;1888:18;:30::i;1734:212:1:-:0;926:13;;719:10:4;;-1:-1:-1;;;;;926:13:1;1833:24;;1825:78;;;;-1:-1:-1;;;1825:78:1;;6915:2:11;1825:78:1;;;6897:21:11;6954:2;6934:18;;;6927:30;6993:34;6973:18;;;6966:62;-1:-1:-1;;;7044:18:11;;;7037:39;7093:19;;1825:78:1;;;;;;;;;1913:26;1932:6;1913:18;:26::i;:::-;1776:170;1734:212::o;12325:552:6:-;12420:17;12439:15;1239:19:2;:17;:19::i;:::-;12466:24:6::1;12493:19;:17;:19::i;:::-;12549:25;::::0;::::1;::::0;12466:46;;-1:-1:-1;12522:24:6::1;12606:32;12466:46:::0;12606:22:::1;:32::i;:::-;12584:54;;12648:34;12685:45;12708:8;12718:11;12685:22;:45::i;:::-;12648:82;;12740:52;12755:8;12765:26;12740:14;:52::i;:::-;12825:45;12830:8;12840:11;12853:16;12825:4;:45::i;:::-;12802:68:::0;;;;-1:-1:-1;12325:552:6;-1:-1:-1;;;;;;;12325:552:6:o;2325:73::-;1094:13:0;:11;:13::i;:::-;1239:19:2::1;:17;:19::i;:::-;2383:8:6::2;:6;:8::i;2066:213::-:0;2214:3;2204:14;;2197:32;;;2208:4;2066:213;;;;;:::o;3183:310::-;3253:22;1094:13:0;:11;:13::i;:::-;3309:4:6;-1:-1:-1;;;;;3297:24:6;::::1;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;3287:34:6;-1:-1:-1;3336:9:6::1;3331:132;3351:15:::0;;::::1;3331:132;;;3400:52;3437:4;3444;;3449:1;3444:7;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;3400:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;3400:28:6::1;::::0;-1:-1:-1;;;3400:52:6:i:1;:::-;3387:7;3395:1;3387:10;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;:65;3368:3:::1;;3331:132;;;;3183:310:::0;;;;:::o;2569:180::-;1150:10;1136:25;;;;:13;:25;;;;;;;;1131:84;;1184:20;;-1:-1:-1;;;1184:20:6;;;;;;;;;;;1131:84;2660:82:::1;2696:23;::::0;;;::::1;::::0;::::1;;:::i;:::-;2721:20;::::0;::::1;;2660:26;;::::0;::::1;2721:13:::0;2660:26:::1;:::i;1139:178:1:-:0;1094:13:0;:11;:13::i;:::-;1228::1::1;:24:::0;;-1:-1:-1;;;;;1228:24:1;::::1;-1:-1:-1::0;;;;;;1228:24:1;;::::1;::::0;::::1;::::0;;;1292:7:::1;1247::0::0;1273:6;-1:-1:-1;;;;;1273:6:0;;1201:85;1292:7:1::1;-1:-1:-1::0;;;;;1267:43:1::1;;;;;;;;;;;1139:178:::0;:::o;1359:130:0:-;1247:7;1273:6;-1:-1:-1;;;;;1273:6:0;719:10:4;1422:23:0;1414:68;;;;-1:-1:-1;;;1414:68:0;;7851:2:11;1414:68:0;;;7833:21:11;;;7870:18;;;7863:30;7929:34;7909:18;;;7902:62;7981:18;;1414:68:0;7649:356:11;1945:106:2;1685:7;;-1:-1:-1;;;1685:7:2;;;;2003:41;;;;-1:-1:-1;;;2003:41:2;;8212:2:11;2003:41:2;;;8194:21:11;8251:2;8231:18;;;8224:30;-1:-1:-1;;;8270:18:11;;;8263:50;8330:18;;2003:41:2;8010:344:11;2433:117:2;1486:16;:14;:16::i;:::-;2491:7:::1;:15:::0;;-1:-1:-1;;;;2491:15:2::1;::::0;;2521:22:::1;719:10:4::0;2530:12:2::1;2521:22;::::0;-1:-1:-1;;;;;1008:32:11;;;990:51;;978:2;963:18;2521:22:2::1;;;;;;;2433:117::o:0;1767:106::-;1685:7;;-1:-1:-1;;;1685:7:2;;;;1836:9;1828:38;;;;-1:-1:-1;;;1828:38:2;;8561:2:11;1828:38:2;;;8543:21:11;8600:2;8580:18;;;8573:30;-1:-1:-1;;;8619:18:11;;;8612:46;8675:18;;1828:38:2;8359:340:11;683:2819:10;725:24;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;725:24:10;852:3;839:17;834:3;830:27;;-1:-1:-1;;;;;910:27:10;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;910:27:10;-1:-1:-1;877:30:10;;;:60;989:12;-1:-1:-1;;;;;975:27:10;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;975:27:10;-1:-1:-1;947:25:10;;;:55;1052:12;-1:-1:-1;;;;;1038:27:10;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1038:27:10;-1:-1:-1;1012:23:10;;;:53;1285:3;1272:17;1267:3;1263:27;1250:41;1208:3;1195:17;1190:3;1186:27;1165:163;1358:11;1345:25;;1342:205;;;-1:-1:-1;;;1434:1:10;1427:77;1531:1;1528;1521:12;1342:205;1599:2;1586:16;1582:2;1578:25;1568:8;1561:43;1694:2;1681:16;1677:2;1673:25;1668:2;1658:8;1654:17;1647:52;1779:3;1766:17;1762:2;1758:26;1753:2;1743:8;1739:17;1732:53;1855:3;1842:17;1837:2;1827:8;1823:17;1816:44;1912:8;1906:3;1896:8;1892:18;1885:36;;2029:3;2016:17;2011:3;2007:27;1994:41;1987:3;1974:17;1969:3;1965:27;1961:75;1955:3;1945:8;1941:18;1934:103;2161:3;2148:17;2143:3;2139:27;2126:41;2119:3;2106:17;2101:3;2097:27;2093:75;2087:3;2077:8;2073:18;2066:103;2243:3;2230:17;2224:3;2214:8;2210:18;2203:45;2370:3;2357:17;2352:3;2348:27;2335:41;2328:3;2315:17;2310:3;2306:27;2302:75;2296:3;2286:8;2282:18;2275:103;2459:3;2446:17;2441:3;2437:27;2431:3;2421:8;2417:18;2410:55;2658:3;2648:8;2644:18;2728:3;2775:1;2744:742;2797:1;2794;2791:8;2744:742;;;2867:2;2854:11;2850:20;2835:35;;2922:1;2887:554;2948:12;2945:1;2942:19;2887:554;;;3224:1;3207:19;;;3194:33;3189:3;3185:43;3172:57;3116:25;;3111:3;3107:35;3074:181;3005:272;;3420:2;3403:20;;;;3365:1;3348:19;;;;3303:9;2887:554;;;-1:-1:-1;3470:1:10;3463:9;2744:742;;;2748:42;;;1115:2381;683:2819;:::o;3722:1661:6:-;3851:25;;;;:32;3802:19;;3851:36;;3802:19;;3851:36;3949:22;;3968:3;3949:22;;;3962:3;3949:22;3925:46;;;;4024:4;4018:11;4004:25;;4071:13;4059:10;4055:30;4049:4;4042:44;4106:10;4134:1;4129:452;;;;4890:66;4878:10;4871:86;4099:872;;4129:452;4500:66;4488:10;4481:86;4099:872;-1:-1:-1;5004:372:6;5094:66;5212;5292:8;5314:10;5338:13;5365:1;5004:25;:372::i;:::-;4990:386;3722:1661;-1:-1:-1;;;;;3722:1661:6:o;3894:862:10:-;4072:23;;;;:30;4003:34;;;4112:638;4136:12;4132:1;:16;4112:638;;;4166:27;4196:8;:30;;;4227:1;4196:33;;;;;;;;:::i;:::-;;;;;;;4166:63;;4243:23;4269:8;:25;;;4295:1;4269:28;;;;;;;;:::i;:::-;;;;;;;4243:54;;4311:21;4335:8;:23;;;4359:1;4335:26;;;;;;;;:::i;:::-;;;;;;;4311:50;;4379:30;:19;-1:-1:-1;;;;;4379:28:10;-1:-1:-1;;;;;640:22:9;;;562:107;4379:30:10;4375:306;;;4429:60;-1:-1:-1;;;;;4429:28:10;;4458:15;4475:13;4429:28;:60::i;:::-;4507:43;4537:13;4507:43;;:::i;:::-;;;4375:306;;;4589:77;-1:-1:-1;;;;;4589:32:10;;4622:11;4635:15;4652:13;4589:32;:77::i;:::-;-1:-1:-1;;;4722:3:10;;4112:638;;;;4039:717;3894:862;;;;:::o;11334:935:6:-;11458:8;:17;;;11479:1;11458:22;11454:471;;11500:25;;;;-1:-1:-1;;;;;11500:34:6;11496:419;;11576:38;11588:26;11576:9;:38;:::i;:::-;11556:17;;;:58;11496:419;;;11673:25;;;;11653:17;;11673:62;;-1:-1:-1;;;;;11673:35:6;11709:10;11729:4;11673:35;:62::i;:::-;11653:82;;11753:15;11771:50;11810:10;11771:8;:25;;;-1:-1:-1;;;;;11771:38:6;;;:50;;;;:::i;:::-;11753:68;;11871:7;11859:9;:19;:41;;11893:7;11859:41;;;11881:9;11859:41;11839:17;;;:61;-1:-1:-1;;11496:419:6;11939:25;;;;-1:-1:-1;;;;;11939:34:6;11935:328;;12045:9;12024:8;:17;;;11995:26;:46;;;;:::i;:::-;:59;11991:126;;12081:21;;-1:-1:-1;;;12081:21:6;;;;;;;;;;;11991:126;11334:935;;:::o;11935:328::-;12181:9;12151:26;:39;12147:106;;12217:21;;-1:-1:-1;;;12217:21:6;;;;;;;;;;;6486:4592;6620:17;6639:15;6678:56;6715:8;:18;;;6678:8;:23;;;-1:-1:-1;;;;;6678:36:6;;;:56;;;;:::i;:::-;6666:68;;6744:28;6775:36;:8;:23;;;-1:-1:-1;;;;;6775:34:6;;:36::i;:::-;6851:17;;;;6744:67;;-1:-1:-1;6879:32:6;6851:8;6879:22;:32::i;:::-;-1:-1:-1;;;;;6926:25:6;;6922:726;;7020:8;:27;;;7016:236;;;7101:11;;7114:17;;;;7067:25;;;;:65;;-1:-1:-1;;;;;7067:33:6;;;;7101:11;;;7067:33;:65::i;:::-;6922:726;;7016:236;7206:11;;7219:17;;;;7171:25;;;;:66;;-1:-1:-1;;;;;7171:34:6;;;;7206:11;;;7171:34;:66::i;6922:726::-;7286:8;:27;;;7282:356;;;7333:85;7372:11;7393:4;7400:8;:17;;;7333:8;:25;;;-1:-1:-1;;;;;7333:38:6;;;:85;;;;;;:::i;:::-;7470:11;;7483:17;;;;7436:25;;;;:65;;-1:-1:-1;;;;;7436:33:6;;;;7470:11;;;7436:33;:65::i;7282:356::-;7592:11;;7605:17;;;;7540:25;;;;:83;;-1:-1:-1;;;;;7540:38:6;;;;7579:11;;7592;;;;7540:38;:83::i;:::-;7658:26;7687:11;;;;;;;;;-1:-1:-1;;;;;7687:11:6;7658:40;;7746:1;7782:4;7776:11;7841:2;7836;7823:16;7819:25;7895:2;7882:11;7878:20;7938:11;7928:8;7924:26;7918:4;7911:40;-1:-1:-1;;;7971:8:6;7964:84;8110:2;8106:1;8096:8;8092:16;8085:28;8152:13;8147:2;8137:8;8133:17;8126:40;8202:4;8196:11;8248:2;8237:9;8233:18;8227:4;8220:32;8301:13;8297:2;8292;8282:8;8278:17;8265:50;8409:2;8399:8;8395:17;8389:24;8383:3;8373:8;8369:18;8362:52;8518:3;8508:8;8504:18;8498:25;8469:54;;8590:2;8580:8;8576:17;8570:24;8566:2;8562:33;8557:2;8547:8;8543:17;8536:60;8636:21;8630:3;8620:8;8616:18;8609:49;8752:2;8741:9;8728:11;8718:8;8715:1;8695:18;8688:5;8683:72;8672:83;;8784:1;8775:7;8772:14;8769:77;;8822:9;8816:16;8805:27;;8769:77;;;;;8875:1;8866:7;8863:14;8860:132;;8917:16;8914:1;8911;8896:38;8961:16;8958:1;8951:27;8860:132;;9074:20;9035:36;:8;:23;;;-1:-1:-1;;;;;9035:34:6;;:36::i;:::-;:59;;;;:::i;:::-;9012:82;;9109:8;:27;;;9105:999;;;9222:18;;9189:23;;;;:74;;-1:-1:-1;;;;;9189:32:6;;;;9242:20;9189:32;:74::i;:::-;9296:25;;;;9277:16;;9296:70;;-1:-1:-1;;;;;9296:35:6;9340:4;9347:18;9296:35;:70::i;:::-;9277:89;;9422:8;9402;:17;;;:28;;;;:::i;:::-;9380:50;-1:-1:-1;9448:12:6;;9444:141;;9514:25;;;;:56;;-1:-1:-1;;;;;9514:33:6;9548:18;9568:1;9514:33;:56::i;:::-;9138:457;9105:999;;;9650:443;9700:8;:18;;;9761:8;:26;;;9737:20;:50;;:85;;;-1:-1:-1;9791:26:6;;;;:31;9737:85;9736:343;;9889:190;9923:8;:26;;;10051:5;10023:8;:24;;;10000:20;:47;;;;:::i;:::-;9999:57;;;;:::i;:::-;9975:82;;:20;:82;:::i;:::-;9889:8;:190::i;:::-;9736:343;;;9846:20;9736:343;9650:23;;;;-1:-1:-1;;;;;9650:32:6;;:443;:32;:443::i;:::-;10163:18;;10126:23;;;;10185:9;;10126:56;;-1:-1:-1;;;;;10126:36:6;;;:56::i;:::-;:68;;;;:::i;:::-;10114:80;;10221:8;:21;;;10209:9;:33;10205:94;;;10265:23;;-1:-1:-1;;;10265:23:6;;;;;;;;;;;10205:94;10309:762;10331:730;;;;;;;;10377:11;-1:-1:-1;;;;;10331:730:6;;;;;10417:8;:18;;;-1:-1:-1;;;;;10331:730:6;;;;;10471:16;-1:-1:-1;;;;;10331:730:6;;;;;10521:8;:23;;;-1:-1:-1;;;;;10331:730:6;;;;;10583:19;10331:730;;;;10642:20;10331:730;;;;10690:8;:17;;;10331:730;;;;10736:9;10331:730;;;;10782:8;:26;;;10331:730;;;;10838:8;:19;;;10331:730;;;;10898:8;:30;;;10331:730;;;;10964:8;:25;;;10331:730;;;;11023:8;:23;;;10331:730;;;10309:8;:762::i;:::-;6656:4422;;;6486:4592;;;;;;:::o;4260:734:9:-;-1:-1:-1;;;;;4350:13:9;;4346:642;;4382:12;4408:9;-1:-1:-1;;;;;4400:23:9;4431:6;4400:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4381:61;;;4461:7;4456:70;;4495:16;;-1:-1:-1;;;4495:16:9;;;;;;;;;;;4456:70;4367:169;2900:227:6::1;2802:331:::0;;:::o;4346:642:9:-;4556:11;4621:4;4615:11;4608:18;;4665:2;4660:3;4656:12;4650:4;4643:26;-1:-1:-1;;;4693:3:9;4686:79;4802:9;4798:1;4793:3;4789:11;4782:30;4850:6;4845:2;4840:3;4836:12;4829:28;4889:31;4897:4;4903:1;4906:3;4911:2;4915:1;4918;4889:7;:31::i;:::-;4884:94;;4947:16;;-1:-1:-1;;;4947:16:9;;;;;;;;;;;1501:153:1;1590:13;1583:20;;-1:-1:-1;;;;;;1583:20:1;;;1613:34;1638:8;1613:24;:34::i;2186:115:2:-;1239:19;:17;:19::i;:::-;2255:4:::1;2245:14:::0;;-1:-1:-1;;;;2245:14:2::1;-1:-1:-1::0;;;2245:14:2::1;::::0;;2274:20:::1;2281:12;719:10:4::0;;640:96;6674:198:3;6757:12;6788:77;6809:6;6817:4;6788:77;;;;;;;;;;;;;;;;;:20;:77::i;:::-;6781:84;6674:198;-1:-1:-1;;;6674:198:3:o;7548:2644:10:-;6735:354;;;6886:66;6735:354;;;;12692:25:11;;;;12733:18;;;12726:34;;;12776:18;;;12769:34;;;6660:9:10;12819:18:11;;;12812:34;7066:4:10;12862:19:11;;;;12855:61;;;;6735:354:10;;;;;;;;;;12664:19:11;;;;6735:354:10;;;6708:395;;;;;7777:19;;7877:14;7901:9;7920;7939:7;7956:20;7979:8;:25;;;:32;7956:55;;8072:9;8067:2;8055:10;8051:19;8044:38;8123:8;8118:2;8106:10;8102:19;8095:37;8179:8;8173:15;8168:2;8156:10;8152:19;8145:44;8251:2;8241:8;8237:17;8231:24;8225:3;8213:10;8209:20;8202:54;8318:2;8308:8;8304:17;8298:24;8292:3;8280:10;8276:20;8269:54;8385:3;8375:8;8371:18;8365:25;8359:3;8347:10;8343:20;8336:55;8453:3;8443:8;8439:18;8433:25;8427:3;8415:10;8411:20;8404:55;8521:3;8511:8;8507:18;8501:25;8495:3;8483:10;8479:20;8472:55;8589:3;8579:8;8575:18;8569:25;8563:3;8551:10;8547:20;8540:55;8657:3;8647:8;8643:18;8637:25;8631:3;8619:10;8615:20;8608:55;8725:3;8715:8;8711:18;8705:25;8699:3;8687:10;8683:20;8676:55;8765:1;8751:12;8748:19;8745:531;;;8863:2;8845:21;;;8839:3;8825:18;;;8815:52;;;8809:3;8793:20;;8786:82;9011:1;8993:20;;8989:29;;;8965:54;;;;8955:88;;;8929:3;8913:20;;8885:176;9182:37;;;;9158:62;;;;9148:96;9106:20;;;9078:184;8745:531;9323:13;9311:10;9301:36;9371:4;9365:11;9351:25;;9418:2;9406:10;9402:19;9396:4;9389:33;-1:-1:-1;;;9442:10:10;9435:30;9505:15;9501:1;9489:10;9485:18;9478:43;9562:4;9557:2;9545:10;9541:19;9534:33;;9612:2;9600:10;9590:25;9580:35;;9647:3;9634:17;9629:22;;9682:3;9669:17;9664:22;;9726:3;9713:17;9708:3;9704:27;9699:32;;9750:22;9775:30;9789:6;9797:1;9800;9803;9775:13;:30::i;:::-;9750:55;;9853:8;9838:23;;9884:14;9881:1;9874:25;9925:19;9919:4;9912:33;9998:1;9990:4;9987:1;9977:18;9971:25;9968:32;9958:218;;-1:-1:-1;;;10063:1:10;10056:77;10160:1;10157;10150:12;9958:218;9824:362;;;;;;;7548:2644;;;;;;;;:::o;3469:524:9:-;3566:11;3623:4;3617:11;3610:18;;3663:3;3658;3654:13;3648:4;3641:27;-1:-1:-1;;;3688:3:9;3681:79;3793:4;3789:1;3784:3;3780:11;3773:25;3832:2;3827;3822:3;3818:12;3811:24;3869:6;3864:2;3859:3;3855:12;3848:28;3901:32;3909:4;3915:1;3918:3;3923;3928:1;3931;3901:7;:32::i;:::-;3896:91;;3956:20;;-1:-1:-1;;;3956:20:9;;;;;;;;;;;3896:91;3556:437;3469:524;;;;:::o;6458:889::-;6546:14;6572:23;6653:4;6647:11;6628:30;;6705:3;6688:15;6684:25;6678:4;6671:39;-1:-1:-1;;;6730:15:9;6723:91;6859:5;6855:1;6838:15;6834:23;6827:38;6911:7;6906:2;6889:15;6885:24;6878:41;6977:2;6960:15;6956:24;7066:2;7048:16;7044:2;7027:15;7021:4;7014:5;7003:66;6993:192;;7110:16;7107:1;7104;7089:38;7154:16;7151:1;7144:27;6993:192;7222:2;7204:16;7201:24;7198:87;;;7254:16;7251:1;7244:27;7198:87;7308:23;;6458:889;-1:-1:-1;;;;;6458:889:9:o;2242:892::-;2324:14;2380:4;2397:71;;;;2536:4;2530:11;2592:2;2575:15;2571:24;2565:4;2558:38;-1:-1:-1;;;2620:15:9;2613:91;2753:13;2749:1;2732:15;2728:23;2721:46;2829:2;2812:15;2808:24;2922:2;2904:16;2900:2;2883:15;2877:4;2870:5;2859:66;2849:204;;2970:16;2967:1;2964;2949:38;3018:16;3015:1;3008:27;2849:204;3081:23;;-1:-1:-1;2373:745:9;;-1:-1:-1;2373:745:9;2397:71;-1:-1:-1;;2432:22:9;;2242:892;-1:-1:-1;2242:892:9:o;1841:123::-;1898:7;1924:33;1937:4;1951;1924:12;:33::i;11084:244:6:-;11164:25;;;;-1:-1:-1;;;;;11164:34:6;11160:162;;11244:4;;-1:-1:-1;;;;;11244:4:6;11216:25;;;:32;;;11293:17;;;;11262:49;;11244:4;11262:30;:49::i;5284:806:9:-;5367:11;5424:4;5418:11;5411:18;;5464:2;5459:3;5455:12;5449:4;5442:26;-1:-1:-1;;;5488:3:9;5481:79;5593:7;5589:1;5584:3;5580:11;5573:28;5635:6;5630:2;5625:3;5621:12;5614:28;5667:31;5675:4;5681:1;5684:3;5689:2;5693:1;5696;5667:7;:31::i;:::-;5662:422;;5762:1;5757:2;5752:3;5748:12;5741:23;5796:31;5804:4;5810:1;5813:3;5818:2;5822:1;5825;5796:7;:31::i;:::-;5791:94;;5854:16;;-1:-1:-1;;;5854:16:9;;;;;;;;;;;5791:94;5946:6;5941:2;5936:3;5932:12;5925:28;5985:31;5993:4;5999:1;6002:3;6007:2;6011:1;6014;5985:7;:31::i;:::-;5980:94;;6043:16;;-1:-1:-1;;;6043:16:9;;;;;;;;;;;413:104:5;471:7;501:1;497;:5;:13;;509:1;497:13;;;-1:-1:-1;505:1:5;;413:104;-1:-1:-1;413:104:5:o;5389:670:6:-;5455:597;5473:1;:13;;;5500:1;:11;;;5525:1;:18;;;5557:1;:16;;;5614:1;:21;;;5601:1;:10;;;:34;:75;;5675:1;5601:75;;;5651:1;:21;;;5638:1;:10;;;:34;;;;:::i;:::-;5587:1;:10;;;:90;;;;:::i;:::-;5691:1;:11;;;5716:1;:19;;;5762:1;:21;;;5749:1;:10;;;:34;:75;;5823:1;5749:75;;;5799:1;:21;;;5786:1;:10;;;:34;;;;:::i;:::-;5863:1;:11;;;5838:1;:22;;;:36;:79;;5916:1;5838:79;;;5902:1;:11;;;5877:1;:22;;;:36;;;;:::i;:::-;5931:1;:12;;;5957:1;:23;;;5994:1;:18;;;6026:1;:16;;;5455:597;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;5389:670;:::o;7393:1202:9:-;7626:11;7672:426;;;7716:12;7761:16;7754:24;7800:1;7795:149;;;;7961:123;;;;7747:337;;7795:149;7830:26;;7827:33;7824:102;;7903:1;7887:17;;7824:102;7795:149;;7961:123;8011:2;8008:1;8005;7990:24;8064:1;8060;8054:8;8051:15;8035:31;;7747:337;;7672:426;;;:::o;:::-;8374:12;8336:16;8296:18;8259:15;8218:19;8192:4;8165:5;8139:265;8112:421;;8458:16;8455:1;8452;8437:38;8502:16;8499:1;8492:27;8112:421;8557:22;8574:4;8557:22;:::i;:::-;8547:32;7393:1202;-1:-1:-1;;;;;;;7393:1202:9:o;2426:187:0:-;2499:16;2518:6;;-1:-1:-1;;;;;2534:17:0;;;-1:-1:-1;;;;;;2534:17:0;;;;;;2566:40;;2518:6;;;;;;;2566:40;;2499:16;2566:40;2489:124;2426:187;:::o;7058:325:3:-;7199:12;7224;7238:23;7265:6;-1:-1:-1;;;;;7265:19:3;7285:4;7265:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7223:67;;;;7307:69;7334:6;7342:7;7351:10;7363:12;7307:26;:69::i;:::-;7300:76;7058:325;-1:-1:-1;;;;;;7058:325:3:o;5152:1343:10:-;5242:14;6159:66;6146:79;;6142:135;;;6248:18;;-1:-1:-1;;;6248:18:10;;;;;;;;;;;6142:135;6290:1;:7;;6295:2;6290:7;;:18;;;;;6301:1;:7;;6306:2;6301:7;;6290:18;6286:74;;;6331:18;;-1:-1:-1;;;6331:18:10;;;;;;;;;;;6286:74;6379:24;;;;;;;;;;;;13154:25:11;;;13227:4;13215:17;;13195:18;;;13188:45;;;;13249:18;;;13242:34;;;13292:18;;;13285:34;;;6379:24:10;;13126:19:11;;6379:24:10;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;6379:24:10;;-1:-1:-1;;6379:24:10;;;-1:-1:-1;;;;;;;6417:20:10;;6413:76;;6460:18;;-1:-1:-1;;;6460:18:10;;;;;;;;;;;6413:76;5152:1343;;;;;;:::o;767:367:9:-;830:11;887:4;881:11;874:18;;927:1;922:3;918:11;912:4;905:25;-1:-1:-1;;;950:3:9;943:79;1047:35;1055:4;1061:6;1069:3;1074:1;1077;1080;1047:7;:35::i;:::-;1042:86;;1105:12;;-1:-1:-1;;;1105:12:9;;;;;;;;;;;7671:628:3;7851:12;7879:7;7875:418;;;7906:10;:17;7927:1;7906:22;7902:286;;-1:-1:-1;;;;;1702:19:3;;;8113:60;;;;-1:-1:-1;;;8113:60:3;;13532:2:11;8113:60:3;;;13514:21:11;13571:2;13551:18;;;13544:30;13610:31;13590:18;;;13583:59;13659:18;;8113:60:3;13330:353:11;8113:60:3;-1:-1:-1;8208:10:3;8201:17;;7875:418;8249:33;8257:10;8269:12;8980:17;;:21;8976:379;;9208:10;9202:17;9264:15;9251:10;9247:2;9243:19;9236:44;8976:379;9331:12;9324:20;;-1:-1:-1;;;9324:20:3;;;;;;;;:::i;14:173:11:-;82:20;;-1:-1:-1;;;;;131:31:11;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:347::-;257:6;265;318:2;306:9;297:7;293:23;289:32;286:52;;;334:1;331;324:12;286:52;357:29;376:9;357:29;:::i;:::-;347:39;;436:2;425:9;421:18;408:32;483:5;476:13;469:21;462:5;459:32;449:60;;505:1;502;495:12;449:60;528:5;518:15;;;192:347;;;;;:::o;544:186::-;603:6;656:2;644:9;635:7;631:23;627:32;624:52;;;672:1;669;662:12;624:52;695:29;714:9;695:29;:::i;1052:586::-;1122:6;1130;1183:2;1171:9;1162:7;1158:23;1154:32;1151:52;;;1199:1;1196;1189:12;1151:52;1239:9;1226:23;-1:-1:-1;;;;;1264:6:11;1261:30;1258:50;;;1304:1;1301;1294:12;1258:50;1327:22;;1380:4;1372:13;;1368:27;-1:-1:-1;1358:55:11;;1409:1;1406;1399:12;1358:55;1449:2;1436:16;-1:-1:-1;;;;;1467:6:11;1464:30;1461:50;;;1507:1;1504;1497:12;1461:50;1552:7;1547:2;1538:6;1534:2;1530:15;1526:24;1523:37;1520:57;;;1573:1;1570;1563:12;1520:57;1604:2;1596:11;;;;;1626:6;;-1:-1:-1;1052:586:11;-1:-1:-1;;;1052:586:11:o;2017:646::-;2136:6;2144;2197:2;2185:9;2176:7;2172:23;2168:32;2165:52;;;2213:1;2210;2203:12;2165:52;2253:9;2240:23;-1:-1:-1;;;;;2278:6:11;2275:30;2272:50;;;2318:1;2315;2308:12;2272:50;2341:22;;2394:4;2386:13;;2382:27;-1:-1:-1;2372:55:11;;2423:1;2420;2413:12;2372:55;2463:2;2450:16;-1:-1:-1;;;;;2481:6:11;2478:30;2475:50;;;2521:1;2518;2511:12;2475:50;2577:7;2572:2;2564:4;2556:6;2552:17;2548:2;2544:26;2540:35;2537:48;2534:68;;;2598:1;2595;2588:12;2921:127;2982:10;2977:3;2973:20;2970:1;2963:31;3013:4;3010:1;3003:15;3037:4;3034:1;3027:15;3053:1068;3130:6;3138;3191:2;3179:9;3170:7;3166:23;3162:32;3159:52;;;3207:1;3204;3197:12;3159:52;3247:9;3234:23;-1:-1:-1;;;;;3272:6:11;3269:30;3266:50;;;3312:1;3309;3302:12;3266:50;3335:22;;3388:4;3380:13;;3376:27;-1:-1:-1;3366:55:11;;3417:1;3414;3407:12;3366:55;3457:2;3444:16;-1:-1:-1;;;;;3475:6:11;3472:30;3469:56;;;3505:18;;:::i;:::-;3554:2;3548:9;3646:2;3608:17;;-1:-1:-1;;3604:31:11;;;3637:2;3600:40;3596:54;3584:67;;-1:-1:-1;;;;;3666:34:11;;3702:22;;;3663:62;3660:88;;;3728:18;;:::i;:::-;3764:2;3757:22;3788;;;3829:15;;;3846:4;3825:26;3822:39;-1:-1:-1;3819:59:11;;;3874:1;3871;3864:12;3819:59;3934:6;3927:4;3923:2;3919:13;3912:4;3904:6;3900:17;3887:54;3989:1;3982:4;3961:19;;;3957:30;;3950:41;3961:19;4070:20;;4057:34;;-1:-1:-1;;;;3053:1068:11:o;4126:288::-;4167:3;4205:5;4199:12;4232:6;4227:3;4220:19;4288:6;4281:4;4274:5;4270:16;4263:4;4258:3;4254:14;4248:47;4340:1;4333:4;4324:6;4319:3;4315:16;4311:27;4304:38;4403:4;4396:2;4392:7;4387:2;4379:6;4375:15;4371:29;4366:3;4362:39;4358:50;4351:57;;;4126:288;;;;:::o;4419:217::-;4566:2;4555:9;4548:21;4529:4;4586:44;4626:2;4615:9;4611:18;4603:6;4586:44;:::i;4641:621::-;4738:6;4746;4799:2;4787:9;4778:7;4774:23;4770:32;4767:52;;;4815:1;4812;4805:12;4767:52;4855:9;4842:23;-1:-1:-1;;;;;4880:6:11;4877:30;4874:50;;;4920:1;4917;4910:12;4874:50;4943:22;;4996:4;4988:13;;4984:27;-1:-1:-1;4974:55:11;;5025:1;5022;5015:12;4974:55;5065:2;5052:16;-1:-1:-1;;;;;5083:6:11;5080:30;5077:50;;;5123:1;5120;5113:12;5077:50;5176:7;5171:2;5161:6;5158:1;5154:14;5150:2;5146:23;5142:32;5139:45;5136:65;;;5197:1;5194;5187:12;5267:779;5427:4;5475:2;5464:9;5460:18;5505:2;5494:9;5487:21;5528:6;5563;5557:13;5594:6;5586;5579:22;5632:2;5621:9;5617:18;5610:25;;5694:2;5684:6;5681:1;5677:14;5666:9;5662:30;5658:39;5644:53;;5732:2;5724:6;5720:15;5753:1;5763:254;5777:6;5774:1;5771:13;5763:254;;;5870:2;5866:7;5854:9;5846:6;5842:22;5838:36;5833:3;5826:49;5898:39;5930:6;5921;5915:13;5898:39;:::i;:::-;5888:49;-1:-1:-1;5972:2:11;5995:12;;;;5960:15;;;;;5799:1;5792:9;5763:254;;;-1:-1:-1;6034:6:11;;5267:779;-1:-1:-1;;;;;;5267:779:11:o;6051:236::-;6143:6;6203:2;6191:9;6182:7;6178:23;6174:32;6218:2;6215:22;;;6233:1;6230;6223:12;6215:22;-1:-1:-1;6272:9:11;;6051:236;-1:-1:-1;;6051:236:11:o;6581:127::-;6642:10;6637:3;6633:20;6630:1;6623:31;6673:4;6670:1;6663:15;6697:4;6694:1;6687:15;7123:521;7200:4;7206:6;7266:11;7253:25;7360:2;7356:7;7345:8;7329:14;7325:29;7321:43;7301:18;7297:68;7287:96;;7379:1;7376;7369:12;7287:96;7406:33;;7458:20;;;-1:-1:-1;;;;;;7490:30:11;;7487:50;;;7533:1;7530;7523:12;7487:50;7566:4;7554:17;;-1:-1:-1;7597:14:11;7593:27;;;7583:38;;7580:58;;;7634:1;7631;7624:12;7580:58;7123:521;;;;;:::o;8704:127::-;8765:10;8760:3;8756:20;8753:1;8746:31;8796:4;8793:1;8786:15;8820:4;8817:1;8810:15;8836:125;8901:9;;;8922:10;;;8919:36;;;8935:18;;:::i;8966:128::-;9033:9;;;9054:11;;;9051:37;;;9068:18;;:::i;9099:168::-;9172:9;;;9203;;9220:15;;;9214:22;;9200:37;9190:71;;9241:18;;:::i;9272:217::-;9312:1;9338;9328:132;;9382:10;9377:3;9373:20;9370:1;9363:31;9417:4;9414:1;9407:15;9445:4;9442:1;9435:15;9328:132;-1:-1:-1;9474:9:11;;9272:217::o;9704:446::-;9757:3;9795:5;9789:12;9822:6;9817:3;9810:19;9854:4;9849:3;9845:14;9838:21;;9893:4;9886:5;9882:16;9916:1;9926:199;9940:6;9937:1;9934:13;9926:199;;;10005:13;;-1:-1:-1;;;;;10001:39:11;9989:52;;10070:4;10061:14;;;;10098:17;;;;10037:1;9955:9;9926:199;;;-1:-1:-1;10141:3:11;;9704:446;-1:-1:-1;;;;9704:446:11:o;10155:420::-;10208:3;10246:5;10240:12;10273:6;10268:3;10261:19;10305:4;10300:3;10296:14;10289:21;;10344:4;10337:5;10333:16;10367:1;10377:173;10391:6;10388:1;10385:13;10377:173;;;10452:13;;10440:26;;10495:4;10486:14;;;;10523:17;;;;10413:1;10406:9;10377:173;;10580:1458;-1:-1:-1;;;;;11198:32:11;;;11180:51;;801:31;;11282:2;11267:18;;789:44;-1:-1:-1;;;;;801:31:11;;11337:2;11322:18;;789:44;-1:-1:-1;;;;;801:31:11;;11392:2;11377:18;;789:44;11433:6;11427:3;11416:9;11412:19;11405:35;11477:6;11471:3;11460:9;11456:19;11449:35;11521:6;11515:3;11504:9;11500:19;11493:35;11565:6;11559:3;11548:9;11544:19;11537:35;11609:6;11603:3;11592:9;11588:19;11581:35;11653:6;11647:3;11636:9;11632:19;11625:35;11697:3;11691;11680:9;11676:19;11669:32;11161:4;11724:58;11777:3;11766:9;11762:19;11753:7;11724:58;:::i;:::-;11831:9;11823:6;11819:22;11813:3;11802:9;11798:19;11791:51;11865:45;11903:6;11894:7;11865:45;:::i;:::-;11851:59;;11959:9;11951:6;11947:22;11941:3;11930:9;11926:19;11919:51;11987:45;12025:6;12016:7;11987:45;:::i;:::-;11979:53;;;10580:1458;;;;;;;;;;;;;;;;:::o;12043:301::-;12172:3;12210:6;12204:13;12256:6;12249:4;12241:6;12237:17;12232:3;12226:37;12318:1;12282:16;;12307:13;;;-1:-1:-1;12282:16:11;12043:301;-1:-1:-1;12043:301:11:o","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220d310e3742de0aa07d448269423afcb0d444db00c4aefea661f286a52957471f364736f6c634300081c0033","offset":8626}},"immutableReferences":{},"transformations":[],"transformationValues":{}},"deployment":{"transactionHash":"0xa2c2e121666ae064f39894a4506ae02e0b3d127fc6577fec2497611e36e30ed0","blockNumber":"25016616","transactionIndex":"269","deployer":"0x9f2eFccb4041236c7b683521de9459958977f694"},"sources":{"npm/openzeppelin-solidity@4.8.2/contracts/access/Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * 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"},"npm/openzeppelin-solidity@4.8.2/contracts/access/Ownable2Step.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (access/Ownable2Step.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./Ownable.sol\";\n\n/**\n * @dev Contract module which provides access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership} and {acceptOwnership}.\n *\n * This module is used through inheritance. It will make available all functions\n * from parent (Ownable).\n */\nabstract contract Ownable2Step is Ownable {\n    address private _pendingOwner;\n\n    event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Returns the address of the pending owner.\n     */\n    function pendingOwner() public view virtual returns (address) {\n        return _pendingOwner;\n    }\n\n    /**\n     * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual override onlyOwner {\n        _pendingOwner = newOwner;\n        emit OwnershipTransferStarted(owner(), newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual override {\n        delete _pendingOwner;\n        super._transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev The new owner accepts the ownership transfer.\n     */\n    function acceptOwnership() public virtual {\n        address sender = _msgSender();\n        require(pendingOwner() == sender, \"Ownable2Step: caller is not the new owner\");\n        _transferOwnership(sender);\n    }\n}\n"},"npm/openzeppelin-solidity@4.8.2/contracts/security/Pausable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which allows children to implement an emergency stop\n * mechanism that can be triggered by an authorized account.\n *\n * This module is used through inheritance. It will make available the\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\n * the functions of your contract. Note that they will not be pausable by\n * simply including this module, only once the modifiers are put in place.\n */\nabstract contract Pausable is Context {\n    /**\n     * @dev Emitted when the pause is triggered by `account`.\n     */\n    event Paused(address account);\n\n    /**\n     * @dev Emitted when the pause is lifted by `account`.\n     */\n    event Unpaused(address account);\n\n    bool private _paused;\n\n    /**\n     * @dev Initializes the contract in unpaused state.\n     */\n    constructor() {\n        _paused = false;\n    }\n\n    /**\n     * @dev Modifier to make a function callable only when the contract is not paused.\n     *\n     * Requirements:\n     *\n     * - The contract must not be paused.\n     */\n    modifier whenNotPaused() {\n        _requireNotPaused();\n        _;\n    }\n\n    /**\n     * @dev Modifier to make a function callable only when the contract is paused.\n     *\n     * Requirements:\n     *\n     * - The contract must be paused.\n     */\n    modifier whenPaused() {\n        _requirePaused();\n        _;\n    }\n\n    /**\n     * @dev Returns true if the contract is paused, and false otherwise.\n     */\n    function paused() public view virtual returns (bool) {\n        return _paused;\n    }\n\n    /**\n     * @dev Throws if the contract is paused.\n     */\n    function _requireNotPaused() internal view virtual {\n        require(!paused(), \"Pausable: paused\");\n    }\n\n    /**\n     * @dev Throws if the contract is not paused.\n     */\n    function _requirePaused() internal view virtual {\n        require(paused(), \"Pausable: not paused\");\n    }\n\n    /**\n     * @dev Triggers stopped state.\n     *\n     * Requirements:\n     *\n     * - The contract must not be paused.\n     */\n    function _pause() internal virtual whenNotPaused {\n        _paused = true;\n        emit Paused(_msgSender());\n    }\n\n    /**\n     * @dev Returns to normal state.\n     *\n     * Requirements:\n     *\n     * - The contract must be paused.\n     */\n    function _unpause() internal virtual whenPaused {\n        _paused = false;\n        emit Unpaused(_msgSender());\n    }\n}\n"},"npm/openzeppelin-solidity@4.8.2/contracts/utils/Address.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\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"},"npm/openzeppelin-solidity@4.8.2/contracts/utils/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (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"},"npm/openzeppelin-solidity@4.8.2/contracts/utils/math/Math.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n    enum Rounding {\n        Down, // Toward negative infinity\n        Up, // Toward infinity\n        Zero // Toward zero\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b) / 2 can overflow.\n        return (a & b) + (a ^ b) / 2;\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds up instead\n     * of rounding down.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b - 1) / b can overflow on addition, so we distribute.\n        return a == 0 ? 0 : (a - 1) / b + 1;\n    }\n\n    /**\n     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\n     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\n     * with further edits by Uniswap Labs also under MIT license.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\n        unchecked {\n            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\n            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n            // variables such that product = prod1 * 2^256 + prod0.\n            uint256 prod0; // Least significant 256 bits of the product\n            uint256 prod1; // Most significant 256 bits of the product\n            assembly {\n                let mm := mulmod(x, y, not(0))\n                prod0 := mul(x, y)\n                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\n            }\n\n            // Handle non-overflow cases, 256 by 256 division.\n            if (prod1 == 0) {\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n                // The surrounding unchecked block does not change this fact.\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n                return prod0 / denominator;\n            }\n\n            // Make sure the result is less than 2^256. Also prevents denominator == 0.\n            require(denominator > prod1, \"Math: mulDiv overflow\");\n\n            ///////////////////////////////////////////////\n            // 512 by 256 division.\n            ///////////////////////////////////////////////\n\n            // Make division exact by subtracting the remainder from [prod1 prod0].\n            uint256 remainder;\n            assembly {\n                // Compute remainder using mulmod.\n                remainder := mulmod(x, y, denominator)\n\n                // Subtract 256 bit number from 512 bit number.\n                prod1 := sub(prod1, gt(remainder, prod0))\n                prod0 := sub(prod0, remainder)\n            }\n\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\n            // See https://cs.stackexchange.com/q/138556/92363.\n\n            // Does not overflow because the denominator cannot be zero at this stage in the function.\n            uint256 twos = denominator & (~denominator + 1);\n            assembly {\n                // Divide denominator by twos.\n                denominator := div(denominator, twos)\n\n                // Divide [prod1 prod0] by twos.\n                prod0 := div(prod0, twos)\n\n                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\n                twos := add(div(sub(0, twos), twos), 1)\n            }\n\n            // Shift in bits from prod1 into prod0.\n            prod0 |= prod1 * twos;\n\n            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\n            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\n            // four bits. That is, denominator * inv = 1 mod 2^4.\n            uint256 inverse = (3 * denominator) ^ 2;\n\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\n            // in modular arithmetic, doubling the correct bits in each step.\n            inverse *= 2 - denominator * inverse; // inverse mod 2^8\n            inverse *= 2 - denominator * inverse; // inverse mod 2^16\n            inverse *= 2 - denominator * inverse; // inverse mod 2^32\n            inverse *= 2 - denominator * inverse; // inverse mod 2^64\n            inverse *= 2 - denominator * inverse; // inverse mod 2^128\n            inverse *= 2 - denominator * inverse; // inverse mod 2^256\n\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\n            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\n            // is no longer required.\n            result = prod0 * inverse;\n            return result;\n        }\n    }\n\n    /**\n     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\n        uint256 result = mulDiv(x, y, denominator);\n        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\n            result += 1;\n        }\n        return result;\n    }\n\n    /**\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\n     *\n     * Inspired by Henry S. Warren, Jr.'s \"Hacker's Delight\" (Chapter 11).\n     */\n    function sqrt(uint256 a) internal pure returns (uint256) {\n        if (a == 0) {\n            return 0;\n        }\n\n        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\n        //\n        // We know that the \"msb\" (most significant bit) of our target number `a` is a power of 2 such that we have\n        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\n        //\n        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\n        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\n        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\n        //\n        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\n        uint256 result = 1 << (log2(a) >> 1);\n\n        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\n        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\n        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\n        // into the expected uint128 result.\n        unchecked {\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            return min(result, a / result);\n        }\n    }\n\n    /**\n     * @notice Calculates sqrt(a), following the selected rounding direction.\n     */\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = sqrt(a);\n            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 128;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 64;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 32;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 16;\n            }\n            if (value >> 8 > 0) {\n                value >>= 8;\n                result += 8;\n            }\n            if (value >> 4 > 0) {\n                value >>= 4;\n                result += 4;\n            }\n            if (value >> 2 > 0) {\n                value >>= 2;\n                result += 2;\n            }\n            if (value >> 1 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log2(value);\n            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10 ** 64) {\n                value /= 10 ** 64;\n                result += 64;\n            }\n            if (value >= 10 ** 32) {\n                value /= 10 ** 32;\n                result += 32;\n            }\n            if (value >= 10 ** 16) {\n                value /= 10 ** 16;\n                result += 16;\n            }\n            if (value >= 10 ** 8) {\n                value /= 10 ** 8;\n                result += 8;\n            }\n            if (value >= 10 ** 4) {\n                value /= 10 ** 4;\n                result += 4;\n            }\n            if (value >= 10 ** 2) {\n                value /= 10 ** 2;\n                result += 2;\n            }\n            if (value >= 10 ** 1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log10(value);\n            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 256, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 16;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 8;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 4;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 2;\n            }\n            if (value >> 8 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log256(value);\n            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);\n        }\n    }\n}\n"},"project/contracts/DexAggregator.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.28;\n\nimport {Ownable2Step} from \"openzeppelin-solidity/contracts/access/Ownable2Step.sol\";\nimport {Pausable} from \"openzeppelin-solidity/contracts/security/Pausable.sol\";\nimport {Address} from \"openzeppelin-solidity/contracts/utils/Address.sol\";\nimport {Math} from \"openzeppelin-solidity/contracts/utils/math/Math.sol\";\nimport {IDexAggregator} from \"./interfaces/IDexAggregator.sol\";\nimport {LibAsset} from \"./libraries/LibAsset.sol\";\nimport {LibRouter, SwapData} from \"./libraries/LibRouter.sol\";\n\nerror InvalidCall();\nerror InvalidCaller();\nerror InvalidFundManager();\nerror InsufficientAmountOut();\nerror InvalidNativeAmount();\n\ncontract DexAggregator is IDexAggregator, Ownable2Step, Pausable {\n    using LibAsset for address;\n\n    mapping(address => bool) public internalCallers;\n    mapping(address => bool) public fundsManagers;\n    address public coreAddress;\n    address public weth;\n\n    modifier onlyInternalCaller() {\n        if (!internalCallers[msg.sender]) {\n            revert InvalidCaller();\n        }\n        _;\n    }\n\n    modifier onlyFundManager() {\n        if (!fundsManagers[msg.sender]) {\n            revert InvalidFundManager();\n        }\n        _;\n    }\n\n    /// @dev See {IDexAggregator-updateInternalCaller}\n    function updateInternalCaller(address caller, bool value) external onlyOwner {\n        internalCallers[caller] = value;\n\n        emit UpdateInternalCaller(msg.sender, caller, value);\n    }\n\n    /// @dev See {IDexAggregator-updateFundsManager}\n    function updateFundsManager(address caller, bool value) external onlyOwner {\n        fundsManagers[caller] = value;\n\n        emit UpdateFundsManager(msg.sender, caller, value);\n    }\n\n    /// @dev See {IDexAggregator-updateCoreAddress}\n    function updateCoreAddress(address value) external onlyOwner {\n        coreAddress = value;\n    }\n\n    /// @dev See {IDexAggregator-updateWeth}\n    function updateWeth(address value) external onlyOwner {\n        weth = value;\n    }\n\n    /// @dev See {IDexAggregator-updateAmountIn}\n    function updateAmountIn(bytes memory data, uint256 amountIn) external pure returns (bytes memory) {\n        assembly {\n            mstore(add(data, 164), amountIn) // 32 + 132\n        }\n\n        return data;\n    }\n\n    /// @dev See {IDexAggregator-pause}\n    function pause() public onlyOwner whenNotPaused {\n        _pause();\n    }\n\n    /// @dev See {IDexAggregator-unpause}\n    function unpause() public onlyOwner whenPaused {\n        _unpause();\n    }\n\n    /// @dev See {IDexAggregator-transfer}\n    function transfer(TransferParam calldata transferParam) external onlyFundManager {\n        transferParam.assetAddress.transfer(transferParam.recipient, transferParam.amount);\n    }\n\n    /// @dev See {IDexAggregator-transferMany}\n    function transferMany(TransferParam[] calldata transferParams) external onlyFundManager {\n        for (uint256 i = 0; i < transferParams.length; ) {\n            transferParams[i].assetAddress.transfer(transferParams[i].recipient, transferParams[i].amount);\n            unchecked {\n                i++;\n            }\n        }\n    }\n\n    /// @dev See {IDexAggregator-multicall}\n    function multicall(bytes[] calldata data) external onlyOwner returns (bytes[] memory results) {\n        results = new bytes[](data.length);\n        for (uint256 i = 0; i < data.length; i++) {\n            results[i] = Address.functionDelegateCall(address(this), data[i]);\n        }\n        return results;\n    }\n\n    /// @dev Verifies the backend signature for a swap operation.\n    /// @param swapData The data structure containing information about the swap.\n    /// @return fromAddress The address to be used for the swap operation.\n    function verifyBackendSignature(SwapData memory swapData) private view returns (address fromAddress) {\n        bool hasSwapFee = swapData.swapFeeReceivers.length > 0;\n        uint256 messagePtr;\n        uint256 messageLength = hasSwapFee ? 480 : 384;\n        assembly {\n            messagePtr := mload(0x40)\n            mstore(0x40, add(messagePtr, messageLength))\n            switch hasSwapFee\n            case 1 {\n                // keccak256(\"Swap(address router,address sender,address recipient,address fromAsset,address toAsset,uint256 deadline,uint256 amountOutMin,uint256 expectedAmountOut,bytes32 consumerId,uint256 maxRetentionBps,bool transferFromRouter,address[] swapFeeAssets,address[] swapFeeReceivers,uint256[] swapFeeAmounts)\")\n                mstore(messagePtr, 0x5044c48dcff133da673c91c7d371f756e221fd81c7b9f02129fcfd724b840e49)\n            }\n            default {\n                // keccak256(\"Swap(address router,address sender,address recipient,address fromAsset,address toAsset,uint256 deadline,uint256 amountOutMin,uint256 expectedAmountOut,bytes32 consumerId,uint256 maxRetentionBps,bool transferFromRouter)\")\n                mstore(messagePtr, 0x088852e96193cda3374c3e36c04a8bd173e0c18999b51fb3f5c5ab52d7da1fe0)\n            }\n        }\n        fromAddress = LibRouter.verifySignature(\n            // keccak256(bytes(\"Dex Aggregator\")),\n            0x19994fa387947b8529d5d57c0c84137061b0be98f1cef929a4710ff4f36aed49,\n            // keccak256(bytes(\"1\")),\n            0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6,\n            swapData,\n            messagePtr,\n            messageLength,\n            2\n        );\n    }\n\n    function emitSwap(EmitSwapParams memory p) private {\n        emit Swap(\n            p.fromAddress,\n            p.toAddress,\n            p.fromAssetAddress,\n            p.toAssetAddress,\n            p.amountIn - (p.amountIn > p.transferredAmountIn ? p.amountIn - p.transferredAmountIn : 0),\n            p.amountOut,\n            p.expectedAmountOut,\n            p.amountIn > p.transferredAmountIn ? p.amountIn - p.transferredAmountIn : 0,\n            p.transferredAmountOut > p.amountOut ? p.transferredAmountOut - p.amountOut : 0,\n            p.consumerId,\n            p.swapFeeAssetAddresses,\n            p.swapFeeReceivers,\n            p.swapFeeAmounts\n        );\n    }\n\n    /// @dev Swaps tokens based on the provided swap data.\n    /// @param swapData The data structure containing information about the swap operation.\n    /// @param fromAddress The address initiating the swap. This address is responsible for the input assets.\n    /// @return amountOut The amount of tokens or assets received after the swap.\n    /// @return gasUsed The amount of gas consumed by the recorded operation.\n    function swap(\n        SwapData memory swapData,\n        address fromAddress,\n        address fromAssetAddress\n    ) private returns (uint256 amountOut, uint256 gasUsed) {\n        amountOut = swapData.toAssetAddress.getBalanceOf(swapData.toAddress);\n        uint256 transferredAmountOut = swapData.toAssetAddress.getBalance();\n        uint256 transferredAmountIn = swapData.amountIn;\n\n        adjustFromAssetAddress(swapData);\n\n        if (fromAssetAddress.isNative()) {\n            // Already transferred and wrapped\n            if (swapData.transferFromRouter) {\n                swapData.fromAssetAddress.approve(coreAddress, swapData.amountIn);\n            } else {\n                swapData.fromAssetAddress.transfer(coreAddress, swapData.amountIn);\n            }\n        } else {\n            if (swapData.transferFromRouter) {\n                swapData.fromAssetAddress.transferFrom(fromAddress, address(this), swapData.amountIn);\n                swapData.fromAssetAddress.approve(coreAddress, swapData.amountIn);\n            } else {\n                swapData.fromAssetAddress.transferFrom(fromAddress, coreAddress, swapData.amountIn);\n            }\n        }\n\n        address currentCoreAddress = coreAddress;\n        assembly {\n            let success := 0\n            let inputPtr := mload(0x40)\n            let inputLength := add(calldataload(36), 68)\n            let payloadLength := sub(inputLength, 68)\n            mstore(0x40, add(inputPtr, inputLength))\n            mstore(inputPtr, 0x158f689400000000000000000000000000000000000000000000000000000000) // swapWithoutSignature\n            mstore(add(inputPtr, 4), 32)\n            mstore(add(inputPtr, 36), payloadLength)\n            let outputPtr := mload(0x40)\n            mstore(0x40, add(outputPtr, 64))\n            calldatacopy(add(inputPtr, 68), 68, payloadLength)\n\n            // Override amountIn\n            mstore(add(inputPtr, 132), mload(add(swapData, 96)))\n\n            // Override fromAssetAddress\n            let afterFromAssetAddress := mload(add(inputPtr, 112))\n            mstore(add(inputPtr, 92), shl(96, mload(add(swapData, 32))))\n            mstore(add(inputPtr, 112), afterFromAssetAddress)\n\n            success := call(gas(), currentCoreAddress, 0, inputPtr, inputLength, outputPtr, 64)\n\n            if eq(success, 1) {\n                gasUsed := mload(outputPtr)\n            }\n\n            if eq(success, 0) {\n                returndatacopy(0, 0, returndatasize())\n                revert(0, returndatasize())\n            }\n        }\n\n        transferredAmountOut = swapData.toAssetAddress.getBalance() - transferredAmountOut;\n\n        if (swapData.transferFromRouter) {\n            // Slippage in fromAsset\n            swapData.toAssetAddress.transfer(swapData.toAddress, transferredAmountOut);\n            uint256 approval = swapData.fromAssetAddress.allowance(address(this), currentCoreAddress);\n            transferredAmountIn = swapData.amountIn - approval;\n            if (approval > 0) {\n                // Reset approval\n                swapData.fromAssetAddress.approve(currentCoreAddress, 0);\n            }\n        } else {\n            // Slippage in toAsset\n            swapData.toAssetAddress.transfer(\n                swapData.toAddress,\n                (transferredAmountOut <= swapData.expectedAmountOut || swapData.expectedAmountOut == 0)\n                    ? transferredAmountOut\n                    : Math.max(\n                        swapData.expectedAmountOut,\n                        transferredAmountOut - ((transferredAmountOut * swapData.maxRetentionBps) / 10000)\n                    )\n            );\n        }\n\n        amountOut = swapData.toAssetAddress.getBalanceOf(swapData.toAddress) - amountOut;\n\n        if (amountOut < swapData.amountOutMin) {\n            revert InsufficientAmountOut();\n        }\n\n        emitSwap(\n            EmitSwapParams({\n                fromAddress: fromAddress,\n                toAddress: swapData.toAddress,\n                fromAssetAddress: fromAssetAddress,\n                toAssetAddress: swapData.toAssetAddress,\n                transferredAmountIn: transferredAmountIn,\n                transferredAmountOut: transferredAmountOut,\n                amountIn: swapData.amountIn,\n                amountOut: amountOut,\n                expectedAmountOut: swapData.expectedAmountOut,\n                consumerId: swapData.consumerId,\n                swapFeeAssetAddresses: swapData.swapFeeAssetAddresses,\n                swapFeeReceivers: swapData.swapFeeReceivers,\n                swapFeeAmounts: swapData.swapFeeAmounts\n            })\n        );\n    }\n\n    function adjustFromAssetAddress(SwapData memory swapData) private {\n        if (swapData.fromAssetAddress.isNative()) {\n            swapData.fromAssetAddress = weth;\n            swapData.fromAssetAddress.wrap(swapData.amountIn);\n        }\n    }\n\n    function adjustAmountIn(SwapData memory swapData, uint256 transferredNativeFeeAmount) private {\n        // Auto\n        if (swapData.amountIn == 0) {\n            if (swapData.fromAssetAddress.isNative()) {\n                swapData.amountIn = msg.value - transferredNativeFeeAmount;\n            } else {\n                uint256 allowance = swapData.fromAssetAddress.allowance(msg.sender, address(this));\n                uint256 balance = swapData.fromAssetAddress.getBalanceOf(msg.sender);\n                swapData.amountIn = allowance < balance ? allowance : balance;\n            }\n        }\n\n        if (swapData.fromAssetAddress.isNative()) {\n            if (transferredNativeFeeAmount + swapData.amountIn != msg.value) {\n                revert InvalidNativeAmount();\n            }\n        } else {\n            if (transferredNativeFeeAmount != msg.value) {\n                revert InvalidNativeAmount();\n            }\n        }\n    }\n\n    /// @dev See {IDexAggregator-estimateSwapGas}\n    function estimateSwapGas(\n        bytes calldata\n    ) external payable whenNotPaused returns (uint256 amountOut, uint256 gasUsed) {\n        SwapData memory swapData = LibRouter.getData();\n        address fromAssetAddress = swapData.fromAssetAddress;\n        address fromAddress = verifyBackendSignature(swapData);\n        uint256 transferredNativeFeeAmount = LibRouter.transferFees(swapData, fromAddress);\n        adjustAmountIn(swapData, transferredNativeFeeAmount);\n        (amountOut, gasUsed) = swap(swapData, fromAddress, fromAssetAddress);\n    }\n\n    /// @dev See {IDexAggregator-swapWithBackendSignature}\n    function swapWithBackendSignature(bytes calldata) external payable whenNotPaused returns (uint256 amountOut) {\n        SwapData memory swapData = LibRouter.getData();\n        address fromAssetAddress = swapData.fromAssetAddress;\n        address fromAddress = verifyBackendSignature(swapData);\n        uint256 transferredNativeFeeAmount = LibRouter.transferFees(swapData, fromAddress);\n        adjustAmountIn(swapData, transferredNativeFeeAmount);\n        (amountOut, ) = swap(swapData, fromAddress, fromAssetAddress);\n    }\n\n    /// @dev Used to receive ethers\n    receive() external payable {}\n}\n"},"project/contracts/interfaces/IDexAggregator.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.28;\n\ninterface IDexAggregator {\n    struct TransferParam {\n        address assetAddress;\n        address recipient;\n        uint256 amount;\n    }\n\n    event UpdateInternalCaller(address indexed sender, address caller, bool value);\n\n    /// @dev Allows the owner to update the whitelisted internal callers.\n    /// @param caller Caller address.\n    /// @param value Disable or enable the related caller.\n    function updateInternalCaller(address caller, bool value) external;\n\n    event UpdateFundsManager(address indexed sender, address caller, bool value);\n\n    /// @dev Allows the owner to update the whitelisted funds managers.\n    /// @param caller Caller address.\n    /// @param value Disable or enable the related caller.\n    function updateFundsManager(address caller, bool value) external;\n\n    /// @dev Allows the owner to update the magpire router core address.\n    /// @param value Core address.\n    function updateCoreAddress(address value) external;\n\n    /// @dev Allows the owner to update the weth address.\n    /// @param value WETH address.\n    function updateWeth(address value) external;\n\n    /// @dev Updates the input amount encoded within a bytes payload.\n    /// @param data The original encoded calldata or payload containing an amount value.\n    /// @param amountIn The new input amount to be inserted into the data payload.\n    /// @return bytes memory The modified data payload with the updated input amount.\n    function updateAmountIn(bytes memory data, uint256 amountIn) external returns (bytes memory);\n\n    /// @dev Called by the owner to pause, triggers stopped state.\n    function pause() external;\n\n    /// @dev Called by the owner to unpause, returns to normal state.\n    function unpause() external;\n\n    struct EmitSwapParams {\n        address fromAddress;\n        address toAddress;\n        address fromAssetAddress;\n        address toAssetAddress;\n        uint256 transferredAmountIn;\n        uint256 transferredAmountOut;\n        uint256 amountIn;\n        uint256 amountOut;\n        uint256 expectedAmountOut;\n        bytes32 consumerId;\n        address[] swapFeeAssetAddresses;\n        address[] swapFeeReceivers;\n        uint256[] swapFeeAmounts;\n    }\n\n    event Swap(\n        address fromAddress,\n        address toAddress,\n        address fromAssetAddress,\n        address toAssetAddress,\n        uint256 amountIn,\n        uint256 amountOut,\n        uint256 expectedAmountOut,\n        uint256 amountInSurplus,\n        uint256 amountOutSurplus,\n        bytes32 consumerId,\n        address[] swapFeeAssetAddresses,\n        address[] swapFeeReceivers,\n        uint256[] swapFeeAmounts\n    );\n\n    /// @dev Transfer asset from router to the recipient.\n    function transfer(TransferParam calldata transferParam) external;\n\n    /// @dev Transfer assets from router to the recipient.\n    function transferMany(TransferParam[] calldata transferParams) external;\n\n    /// @dev Makes it possible to execute multiple functions in the same transaction.\n    function multicall(bytes[] calldata data) external returns (bytes[] memory results);\n\n    /// @dev Provides an external interface to estimate the gas cost of the last hop in a route.\n    /// @return amountOut The amount received after swapping.\n    /// @return gasUsed The cost of gas while performing the swap.\n    function estimateSwapGas(bytes calldata swapArgs) external payable returns (uint256 amountOut, uint256 gasUsed);\n\n    /// @dev Performs token swap with magpie signature.\n    /// @return amountOut The amount received after swapping.\n    function swapWithBackendSignature(bytes calldata swapArgs) external payable returns (uint256 amountOut);\n}\n"},"project/contracts/interfaces/IWETH.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.28;\n\ninterface IWETH {\n    function deposit() external payable;\n\n    function transfer(address to, uint256 value) external returns (bool);\n\n    function withdraw(uint256) external;\n}\n"},"project/contracts/libraries/LibAsset.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.28;\n\nimport \"../interfaces/IWETH.sol\";\n\nerror AssetNotReceived();\nerror ApprovalFailed();\nerror TransferFromFailed();\nerror TransferFailed();\nerror FailedWrap();\nerror FailedUnwrap();\n\nlibrary LibAsset {\n    using LibAsset for address;\n\n    address constant NATIVE_ASSETID = address(0);\n\n    /// @dev Checks if the given address (self) represents a native asset (Ether).\n    /// @param self The asset that will be checked for a native token.\n    /// @return Flag to identify if the asset is native or not.\n    function isNative(address self) internal pure returns (bool) {\n        return self == NATIVE_ASSETID;\n    }\n\n    /// @dev Wraps the specified asset.\n    /// @param self The asset that will be wrapped.\n    function wrap(address self, uint256 amount) internal {\n        uint256 ptr;\n        assembly {\n            ptr := mload(0x40)\n            mstore(0x40, add(ptr, 4))\n            mstore(ptr, 0xd0e30db000000000000000000000000000000000000000000000000000000000)\n        }\n\n        if (!execute(self, amount, ptr, 4, 0, 0)) {\n            revert FailedWrap();\n        }\n    }\n\n    /// @dev Unwraps the specified asset.\n    /// @param self The asset that will be unwrapped.\n    function unwrap(address self, uint256 amount) internal {\n        uint256 ptr;\n        assembly {\n            ptr := mload(0x40)\n            mstore(0x40, add(ptr, 36))\n            mstore(ptr, 0x2e1a7d4d00000000000000000000000000000000000000000000000000000000)\n            mstore(add(ptr, 4), amount)\n        }\n\n        if (!execute(self, 0, ptr, 36, 0, 0)) {\n            revert FailedUnwrap();\n        }\n    }\n\n    /// @dev Retrieves the balance of the current contract for a given asset (self).\n    /// @param self Asset whose balance needs to be found.\n    /// @return Balance of the specific asset.\n    function getBalance(address self) internal view returns (uint256) {\n        return getBalanceOf(self, address(this));\n    }\n\n    /// @dev Retrieves the balance of the target address for a given asset (self).\n    /// @param self Asset whose balance needs to be found.\n    /// @param targetAddress The address where the balance is checked from.\n    /// @return amount Balance of the specific asset.\n    function getBalanceOf(address self, address targetAddress) internal view returns (uint256 amount) {\n        assembly {\n            switch self\n            case 0 {\n                amount := balance(targetAddress)\n            }\n            default {\n                let currentInputPtr := mload(0x40)\n                mstore(0x40, add(currentInputPtr, 68))\n                mstore(currentInputPtr, 0x70a0823100000000000000000000000000000000000000000000000000000000)\n                mstore(add(currentInputPtr, 4), targetAddress)\n                let currentOutputPtr := add(currentInputPtr, 36)\n                if iszero(staticcall(gas(), self, currentInputPtr, 36, currentOutputPtr, 32)) {\n                    returndatacopy(0, 0, returndatasize())\n                    revert(0, returndatasize())\n                }\n\n                amount := mload(currentOutputPtr)\n            }\n        }\n    }\n\n    /// @dev Performs a safe transferFrom operation for a given asset (self) from one address (from) to another address (to).\n    /// @param self Asset that will be transferred.\n    /// @param from Address that will send the asset.\n    /// @param to Address that will receive the asset.\n    /// @param amount Transferred amount.\n    function transferFrom(address self, address from, address to, uint256 amount) internal {\n        uint256 ptr;\n        assembly {\n            ptr := mload(0x40)\n            mstore(0x40, add(ptr, 100))\n            mstore(ptr, 0x23b872dd00000000000000000000000000000000000000000000000000000000)\n            mstore(add(ptr, 4), from)\n            mstore(add(ptr, 36), to)\n            mstore(add(ptr, 68), amount)\n        }\n\n        if (!execute(self, 0, ptr, 100, 0, 0)) {\n            revert TransferFromFailed();\n        }\n    }\n\n    /// @dev Transfers a given amount of an asset (self) to a recipient address (recipient).\n    /// @param self Asset that will be transferred.\n    /// @param recipient Address that will receive the transferred asset.\n    /// @param amount Transferred amount.\n    function transfer(address self, address recipient, uint256 amount) internal {\n        if (self.isNative()) {\n            (bool success, ) = payable(recipient).call{value: amount}(\"\");\n            if (!success) {\n                revert TransferFailed();\n            }\n        } else {\n            uint256 ptr;\n            assembly {\n                ptr := mload(0x40)\n                mstore(0x40, add(ptr, 68))\n                mstore(ptr, 0xa9059cbb00000000000000000000000000000000000000000000000000000000)\n                mstore(add(ptr, 4), recipient)\n                mstore(add(ptr, 36), amount)\n            }\n            if (!execute(self, 0, ptr, 68, 0, 0)) {\n                revert TransferFailed();\n            }\n        }\n    }\n\n    /// @dev Approves a spender address (spender) to spend a specified amount of an asset (self).\n    /// @param self The asset that will be approved.\n    /// @param spender Address of a contract that will spend the owners asset.\n    /// @param amount Asset amount that can be spent.\n    function approve(address self, address spender, uint256 amount) internal {\n        uint256 ptr;\n        assembly {\n            ptr := mload(0x40)\n            mstore(0x40, add(ptr, 68))\n            mstore(ptr, 0x095ea7b300000000000000000000000000000000000000000000000000000000)\n            mstore(add(ptr, 4), spender)\n            mstore(add(ptr, 36), amount)\n        }\n\n        if (!execute(self, 0, ptr, 68, 0, 0)) {\n            assembly {\n                mstore(add(ptr, 36), 0)\n            }\n            if (!execute(self, 0, ptr, 68, 0, 0)) {\n                revert ApprovalFailed();\n            }\n            assembly {\n                mstore(add(ptr, 36), amount)\n            }\n            if (!execute(self, 0, ptr, 68, 0, 0)) {\n                revert ApprovalFailed();\n            }\n        }\n    }\n\n    /// @dev Returns the remaining number of tokens that spender is allowed to spend on behalf of owner.\n    /// @param self The asset that will be approved.\n    /// @param owner Address of a contract that will owner the asset.\n    /// @param spender Address of a contract that will spend the owners asset.\n    /// @return amount Asset amount that can be spent.\n    function allowance(address self, address owner, address spender) internal view returns (uint256 amount) {\n        uint256 currentInputPtr;\n        assembly {\n            currentInputPtr := mload(0x40)\n            mstore(0x40, add(currentInputPtr, 100))\n            mstore(currentInputPtr, 0xdd62ed3e00000000000000000000000000000000000000000000000000000000)\n            mstore(add(currentInputPtr, 4), owner)\n            mstore(add(currentInputPtr, 36), spender)\n            let currentOutputPtr := add(currentInputPtr, 68)\n            if iszero(staticcall(gas(), self, currentInputPtr, 68, currentOutputPtr, 32)) {\n                returndatacopy(0, 0, returndatasize())\n                revert(0, returndatasize())\n            }\n            if lt(returndatasize(), 32) {\n                revert(0, returndatasize())\n            }\n            amount := mload(currentOutputPtr)\n        }\n    }\n\n    /// @dev Executes a low level call.\n    function execute(\n        address self,\n        uint256 currentNativeAmount,\n        uint256 currentInputPtr,\n        uint256 currentInputLength,\n        uint256 currentOutputPtr,\n        uint256 outputLength\n    ) internal returns (bool result) {\n        assembly {\n            function isSuccessfulCall(targetAddress) -> isSuccessful {\n                switch iszero(returndatasize())\n                case 1 {\n                    if gt(extcodesize(targetAddress), 0) {\n                        isSuccessful := 1\n                    }\n                }\n                case 0 {\n                    returndatacopy(0, 0, 32)\n                    isSuccessful := gt(mload(0), 0)\n                }\n            }\n\n            if iszero(\n                call(\n                    gas(),\n                    self,\n                    currentNativeAmount,\n                    currentInputPtr,\n                    currentInputLength,\n                    currentOutputPtr,\n                    outputLength\n                )\n            ) {\n                returndatacopy(0, 0, returndatasize())\n                revert(0, returndatasize())\n            }\n\n            result := isSuccessfulCall(self)\n        }\n    }\n}\n"},"project/contracts/libraries/LibRouter.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.28;\n\nimport {LibAsset} from \"../libraries/LibAsset.sol\";\n\nstruct SwapData {\n    address toAddress;\n    address fromAssetAddress;\n    address toAssetAddress;\n    uint256 amountIn;\n    uint256 deadline;\n    uint256 amountOutMin;\n    uint256 expectedAmountOut;\n    bytes32 consumerId;\n    uint256 maxRetentionBps;\n    bool transferFromRouter;\n    address[] swapFeeAssetAddresses;\n    address[] swapFeeReceivers;\n    uint256[] swapFeeAmounts;\n}\n\nerror InvalidSignature();\nerror InvalidNativeFeeAmount();\nerror ExpiredTransaction();\n\nlibrary LibRouter {\n    using LibAsset for address;\n\n    /// @dev Prepares SwapData from calldata\n    function getData() internal view returns (SwapData memory swapData) {\n        uint256 swapFeeCount;\n        assembly {\n            swapFeeCount := shr(248, calldataload(274))\n        }\n\n        swapData.swapFeeAssetAddresses = new address[](swapFeeCount);\n        swapData.swapFeeReceivers = new address[](swapFeeCount);\n        swapData.swapFeeAmounts = new uint256[](swapFeeCount);\n\n        // dataOffset: 68 + 2\n        assembly {\n            // Fill\n            let deadline := shr(\n                shr(248, calldataload(164)), // dataOffset + 74\n                calldataload(shr(240, calldataload(165))) // dataOffset + 74 + 1\n            )\n\n            if lt(deadline, timestamp()) {\n                // ExpiredTransaction\n                mstore(0, 0x931997cf00000000000000000000000000000000000000000000000000000000)\n                revert(0, 4)\n            }\n\n            mstore(swapData, shr(96, calldataload(72))) // toAddress / dataOffset + 2\n            mstore(add(swapData, 32), shr(96, calldataload(92))) // fromAssetAddress\n            mstore(add(swapData, 64), shr(96, calldataload(112))) // toAssetAddress\n            mstore(add(swapData, 96), calldataload(132)) // amountIn\n            mstore(add(swapData, 128), deadline)\n            mstore(add(swapData, 160), shr(shr(248, calldataload(167)), calldataload(shr(240, calldataload(168))))) // amountOutMin\n            mstore(add(swapData, 192), shr(shr(248, calldataload(170)), calldataload(shr(240, calldataload(171))))) // expectedAmountOut\n            mstore(add(swapData, 224), calldataload(173)) // consumerId\n            mstore(add(swapData, 256), shr(shr(248, calldataload(205)), calldataload(shr(240, calldataload(206))))) // maxRetentionBps\n            mstore(add(swapData, 288), shr(248, calldataload(208))) // transferFromRouter\n            // calldataload(209) // r\n            // calldataload(241) // s\n            // shr(248, calldataload(273)) // v\n\n            let swapDataPtr := add(swapData, 416) // 320 + 96 Position placeholders\n            let callDataPtr := 275\n            for {\n                let i := 0\n            } lt(i, 3) {\n\n            } {\n                swapDataPtr := add(swapDataPtr, 32)\n                for {\n                    let j := 0\n                } lt(j, swapFeeCount) {\n\n                } {\n                    mstore(\n                        swapDataPtr,\n                        shr(\n                            shr(248, calldataload(callDataPtr)),\n                            calldataload(shr(240, calldataload(add(callDataPtr, 1))))\n                        )\n                    )\n                    j := add(j, 1)\n                    callDataPtr := add(callDataPtr, 3)\n                    swapDataPtr := add(swapDataPtr, 32)\n                }\n                i := add(i, 1)\n            }\n        }\n    }\n\n    /// @dev Transfers the required fees for the swap operation from the user's account.\n    /// @param swapData The data structure containing the details of the swap operation, including fee information.\n    /// @param fromAddress The address of the user from whom the fees will be deducted.\n    /// @return transferredNativeFeeAmount Total transferred fee amount in fromAssetAddress.\n    function transferFees(\n        SwapData memory swapData,\n        address fromAddress\n    ) internal returns (uint256 transferredNativeFeeAmount) {\n        uint256 swapFeeCount = swapData.swapFeeAmounts.length;\n        for (uint256 i = 0; i < swapFeeCount; ) {\n            address swapFeeAssetAddress = swapData.swapFeeAssetAddresses[i];\n            address swapFeeReceiver = swapData.swapFeeReceivers[i];\n            uint256 swapFeeAmount = swapData.swapFeeAmounts[i];\n            if (swapFeeAssetAddress.isNative()) {\n                swapFeeAssetAddress.transfer(swapFeeReceiver, swapFeeAmount);\n                transferredNativeFeeAmount += swapFeeAmount;\n            } else {\n                swapFeeAssetAddress.transferFrom(fromAddress, swapFeeReceiver, swapFeeAmount);\n            }\n            unchecked {\n                i++;\n            }\n        }\n    }\n\n    /// @dev Recovers the signer's address from a hashed message and signature components.\n    /// @param hash The hash of the message that was signed.\n    /// @param r The `r` component of the signature.\n    /// @param s The `s` component of the signature.\n    /// @param v The `v` component of the signature.\n    /// @return signer The address of the signer recovered from the signature.\n    function recoverSigner(bytes32 hash, bytes32 r, bytes32 s, uint8 v) private pure returns (address signer) {\n        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\n        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\n        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most\n        // signatures from current libraries generate a unique signature with an s-value in the lower half order.\n        //\n        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\n        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\n        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\n        // these malleable signatures as well.\n        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\n            revert InvalidSignature();\n        }\n        if (v != 27 && v != 28) {\n            revert InvalidSignature();\n        }\n\n        signer = ecrecover(hash, v, r, s);\n        if (signer == address(0)) {\n            revert InvalidSignature();\n        }\n    }\n\n    function getDomainSeparator(bytes32 name, bytes32 version) private view returns (bytes32) {\n        uint256 chainId;\n        assembly {\n            chainId := chainid()\n        }\n\n        return\n            keccak256(\n                abi.encode(\n                    // keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\")\n                    0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f,\n                    name,\n                    version,\n                    chainId,\n                    address(this)\n                )\n            );\n    }\n\n    /// @dev Verifies the signature for a swap operation.\n    /// @param swapData The SwapData struct containing swap details.\n    /// @param messagePtr Pointer to the message data in memory.\n    /// @param messageLength Length of the message data.\n    /// @param internalCallersSlot Slot in the internal callers storage for verification.\n    /// @return fromAddress The address of the signer / or caller if the signature is valid.\n    function verifySignature(\n        bytes32 name,\n        bytes32 version,\n        SwapData memory swapData,\n        uint256 messagePtr,\n        uint256 messageLength,\n        uint8 internalCallersSlot\n    ) internal view returns (address fromAddress) {\n        bytes32 domainSeparator = getDomainSeparator(name, version);\n        bytes32 digest;\n        bytes32 r;\n        bytes32 s;\n        uint8 v;\n        uint256 swapFeeCount = swapData.swapFeeReceivers.length;\n        assembly {\n            mstore(add(messagePtr, 32), address())\n            mstore(add(messagePtr, 64), caller())\n            mstore(add(messagePtr, 96), mload(swapData))\n            mstore(add(messagePtr, 128), mload(add(swapData, 32)))\n            mstore(add(messagePtr, 160), mload(add(swapData, 64)))\n            mstore(add(messagePtr, 192), mload(add(swapData, 128)))\n            mstore(add(messagePtr, 224), mload(add(swapData, 160)))\n            mstore(add(messagePtr, 256), mload(add(swapData, 192)))\n            mstore(add(messagePtr, 288), mload(add(swapData, 224)))\n            mstore(add(messagePtr, 320), mload(add(swapData, 256)))\n            mstore(add(messagePtr, 352), mload(add(swapData, 288)))\n\n            if gt(swapFeeCount, 0) {\n                mstore(add(messagePtr, 384), keccak256(add(swapData, 448), mul(swapFeeCount, 32)))\n                mstore(\n                    add(messagePtr, 416),\n                    keccak256(add(add(swapData, 448), mul(add(swapFeeCount, 1), 32)), mul(swapFeeCount, 32))\n                )\n                mstore(\n                    add(messagePtr, 448),\n                    keccak256(add(add(swapData, 448), mul(mul(add(swapFeeCount, 1), 32), 2)), mul(swapFeeCount, 32))\n                )\n            }\n            let hash := keccak256(messagePtr, messageLength)\n\n            messagePtr := mload(0x40)\n            mstore(0x40, add(messagePtr, 66))\n            mstore(messagePtr, \"\\x19\\x01\")\n            mstore(add(messagePtr, 2), domainSeparator)\n            mstore(add(messagePtr, 34), hash)\n            digest := keccak256(messagePtr, 66)\n\n            r := calldataload(209)\n            s := calldataload(241)\n            v := shr(248, calldataload(273))\n        }\n        address internalCaller = recoverSigner(digest, r, s, v);\n        assembly {\n            fromAddress := caller()\n            mstore(0, internalCaller)\n            mstore(0x20, internalCallersSlot)\n            if iszero(eq(sload(keccak256(0, 0x40)), 1)) {\n                // InvalidSignature\n                mstore(0, 0x8baa579f00000000000000000000000000000000000000000000000000000000)\n                revert(0, 4)\n            }\n        }\n    }\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.28+commit.7893614a","compilerSettings":{"libraries":{},"optimizer":{"runs":200,"enabled":true},"evmVersion":"cancun","remappings":["project/:openzeppelin-solidity/=npm/openzeppelin-solidity@4.8.2/"]},"name":"DexAggregator","fullyQualifiedName":"project/contracts/DexAggregator.sol:DexAggregator"},"abi":[{"name":"ApprovalFailed","type":"error","inputs":[]},{"name":"FailedWrap","type":"error","inputs":[]},{"name":"InsufficientAmountOut","type":"error","inputs":[]},{"name":"InvalidFundManager","type":"error","inputs":[]},{"name":"InvalidNativeAmount","type":"error","inputs":[]},{"name":"InvalidSignature","type":"error","inputs":[]},{"name":"TransferFailed","type":"error","inputs":[]},{"name":"TransferFromFailed","type":"error","inputs":[]},{"name":"OwnershipTransferStarted","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Paused","type":"event","inputs":[{"name":"account","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"Swap","type":"event","inputs":[{"name":"fromAddress","type":"address","indexed":false,"internalType":"address"},{"name":"toAddress","type":"address","indexed":false,"internalType":"address"},{"name":"fromAssetAddress","type":"address","indexed":false,"internalType":"address"},{"name":"toAssetAddress","type":"address","indexed":false,"internalType":"address"},{"name":"amountIn","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"amountOut","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"expectedAmountOut","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"amountInSurplus","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"amountOutSurplus","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"consumerId","type":"bytes32","indexed":false,"internalType":"bytes32"},{"name":"swapFeeAssetAddresses","type":"address[]","indexed":false,"internalType":"address[]"},{"name":"swapFeeReceivers","type":"address[]","indexed":false,"internalType":"address[]"},{"name":"swapFeeAmounts","type":"uint256[]","indexed":false,"internalType":"uint256[]"}],"anonymous":false},{"name":"Unpaused","type":"event","inputs":[{"name":"account","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"UpdateFundsManager","type":"event","inputs":[{"name":"sender","type":"address","indexed":true,"internalType":"address"},{"name":"caller","type":"address","indexed":false,"internalType":"address"},{"name":"value","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"UpdateInternalCaller","type":"event","inputs":[{"name":"sender","type":"address","indexed":true,"internalType":"address"},{"name":"caller","type":"address","indexed":false,"internalType":"address"},{"name":"value","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"acceptOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"coreAddress","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"estimateSwapGas","type":"function","inputs":[{"name":"","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"amountOut","type":"uint256","internalType":"uint256"},{"name":"gasUsed","type":"uint256","internalType":"uint256"}],"stateMutability":"payable"},{"name":"fundsManagers","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"internalCallers","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"multicall","type":"function","inputs":[{"name":"data","type":"bytes[]","internalType":"bytes[]"}],"outputs":[{"name":"results","type":"bytes[]","internalType":"bytes[]"}],"stateMutability":"nonpayable"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"pause","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"paused","type":"function","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"pendingOwner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"swapWithBackendSignature","type":"function","inputs":[{"name":"","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"amountOut","type":"uint256","internalType":"uint256"}],"stateMutability":"payable"},{"name":"transfer","type":"function","inputs":[{"name":"transferParam","type":"tuple","components":[{"name":"assetAddress","type":"address","internalType":"address"},{"name":"recipient","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"internalType":"struct IDexAggregator.TransferParam"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"transferMany","type":"function","inputs":[{"name":"transferParams","type":"tuple[]","components":[{"name":"assetAddress","type":"address","internalType":"address"},{"name":"recipient","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"internalType":"struct IDexAggregator.TransferParam[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"unpause","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateAmountIn","type":"function","inputs":[{"name":"data","type":"bytes","internalType":"bytes"},{"name":"amountIn","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bytes","internalType":"bytes"}],"stateMutability":"pure"},{"name":"updateCoreAddress","type":"function","inputs":[{"name":"value","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateFundsManager","type":"function","inputs":[{"name":"caller","type":"address","internalType":"address"},{"name":"value","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateInternalCaller","type":"function","inputs":[{"name":"caller","type":"address","internalType":"address"},{"name":"value","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateWeth","type":"function","inputs":[{"name":"value","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"weth","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"receive","stateMutability":"payable"}],"metadata":{"compiler":{"version":"0.8.28+commit.7893614a"},"language":"Solidity","output":{"abi":[{"inputs":[],"name":"ApprovalFailed","type":"error"},{"inputs":[],"name":"FailedWrap","type":"error"},{"inputs":[],"name":"InsufficientAmountOut","type":"error"},{"inputs":[],"name":"InvalidFundManager","type":"error"},{"inputs":[],"name":"InvalidNativeAmount","type":"error"},{"inputs":[],"name":"InvalidSignature","type":"error"},{"inputs":[],"name":"TransferFailed","type":"error"},{"inputs":[],"name":"TransferFromFailed","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"fromAddress","type":"address"},{"indexed":false,"internalType":"address","name":"toAddress","type":"address"},{"indexed":false,"internalType":"address","name":"fromAssetAddress","type":"address"},{"indexed":false,"internalType":"address","name":"toAssetAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountIn","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountOut","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"expectedAmountOut","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountInSurplus","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountOutSurplus","type":"uint256"},{"indexed":false,"internalType":"bytes32","name":"consumerId","type":"bytes32"},{"indexed":false,"internalType":"address[]","name":"swapFeeAssetAddresses","type":"address[]"},{"indexed":false,"internalType":"address[]","name":"swapFeeReceivers","type":"address[]"},{"indexed":false,"internalType":"uint256[]","name":"swapFeeAmounts","type":"uint256[]"}],"name":"Swap","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"address","name":"caller","type":"address"},{"indexed":false,"internalType":"bool","name":"value","type":"bool"}],"name":"UpdateFundsManager","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"address","name":"caller","type":"address"},{"indexed":false,"internalType":"bool","name":"value","type":"bool"}],"name":"UpdateInternalCaller","type":"event"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"coreAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"","type":"bytes"}],"name":"estimateSwapGas","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint256","name":"gasUsed","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"fundsManagers","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"internalCallers","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes[]","name":"data","type":"bytes[]"}],"name":"multicall","outputs":[{"internalType":"bytes[]","name":"results","type":"bytes[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"","type":"bytes"}],"name":"swapWithBackendSignature","outputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"assetAddress","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct IDexAggregator.TransferParam","name":"transferParam","type":"tuple"}],"name":"transfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"assetAddress","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct IDexAggregator.TransferParam[]","name":"transferParams","type":"tuple[]"}],"name":"transferMany","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"uint256","name":"amountIn","type":"uint256"}],"name":"updateAmountIn","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"value","type":"address"}],"name":"updateCoreAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"caller","type":"address"},{"internalType":"bool","name":"value","type":"bool"}],"name":"updateFundsManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"caller","type":"address"},{"internalType":"bool","name":"value","type":"bool"}],"name":"updateInternalCaller","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"value","type":"address"}],"name":"updateWeth","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"weth","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}],"devdoc":{"events":{"Paused(address)":{"details":"Emitted when the pause is triggered by `account`."},"Unpaused(address)":{"details":"Emitted when the pause is lifted by `account`."}},"kind":"dev","methods":{"acceptOwnership()":{"details":"The new owner accepts the ownership transfer."},"estimateSwapGas(bytes)":{"details":"See {IDexAggregator-estimateSwapGas}"},"multicall(bytes[])":{"details":"See {IDexAggregator-multicall}"},"owner()":{"details":"Returns the address of the current owner."},"pause()":{"details":"See {IDexAggregator-pause}"},"paused()":{"details":"Returns true if the contract is paused, and false otherwise."},"pendingOwner()":{"details":"Returns the address of the pending owner."},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"swapWithBackendSignature(bytes)":{"details":"See {IDexAggregator-swapWithBackendSignature}"},"transfer((address,address,uint256))":{"details":"See {IDexAggregator-transfer}"},"transferMany((address,address,uint256)[])":{"details":"See {IDexAggregator-transferMany}"},"transferOwnership(address)":{"details":"Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one. Can only be called by the current owner."},"unpause()":{"details":"See {IDexAggregator-unpause}"},"updateAmountIn(bytes,uint256)":{"details":"See {IDexAggregator-updateAmountIn}"},"updateCoreAddress(address)":{"details":"See {IDexAggregator-updateCoreAddress}"},"updateFundsManager(address,bool)":{"details":"See {IDexAggregator-updateFundsManager}"},"updateInternalCaller(address,bool)":{"details":"See {IDexAggregator-updateInternalCaller}"},"updateWeth(address)":{"details":"See {IDexAggregator-updateWeth}"}},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"compilationTarget":{"project/contracts/DexAggregator.sol":"DexAggregator"},"evmVersion":"cancun","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":200},"remappings":["project/:openzeppelin-solidity/=npm/openzeppelin-solidity@4.8.2/"]},"sources":{"npm/openzeppelin-solidity@4.8.2/contracts/access/Ownable.sol":{"keccak256":"0x923b9774b81c1abfb992262ae7763b6e6de77b077a7180d53c6ebb7b1c8bd648","license":"MIT","urls":["bzz-raw://53445dc0431f9b45c06f567c6091da961d4087bec0010cca5bd62100fa624a38","dweb:/ipfs/QmNvBYpBv183czrAqNXr76E8M3LF93ouAJFeAcHfb59Rcx"]},"npm/openzeppelin-solidity@4.8.2/contracts/access/Ownable2Step.sol":{"keccak256":"0x7cdab82b437a17902683a413c86d14f512674a0710007bf44c584a2d2d3ca833","license":"MIT","urls":["bzz-raw://ffe4db7a9f3cdd5a5d019462c2859f4f98f7aae08704afdcb3ef0d08d966bbeb","dweb:/ipfs/QmTCHSuoi22dAu55qv4TcENyTmv5mTpAoxmYWD8cRnEp3M"]},"npm/openzeppelin-solidity@4.8.2/contracts/security/Pausable.sol":{"keccak256":"0x0849d93b16c9940beb286a7864ed02724b248b93e0d80ef6355af5ef15c64773","license":"MIT","urls":["bzz-raw://4ddabb16009cd17eaca3143feadf450ac13e72919ebe2ca50e00f61cb78bc004","dweb:/ipfs/QmSPwPxX7d6TTWakN5jy5wsaGkS1y9TW8fuhGSraMkLk2B"]},"npm/openzeppelin-solidity@4.8.2/contracts/utils/Address.sol":{"keccak256":"0xa6dfb97ce947b7c846b054ee7d45d12383359778f4f3743654ae0a34fa421b26","license":"MIT","urls":["bzz-raw://b97e7e5a77ea47c08ba422291df887eba76c80982f52a6e94a30106e9377a94f","dweb:/ipfs/Qme7N2XRC7mcDxB8wZxNWPk6T8S2qsnmhAqXeUj4CNvsGD"]},"npm/openzeppelin-solidity@4.8.2/contracts/utils/Context.sol":{"keccak256":"0xe2e337e6dde9ef6b680e07338c493ebea1b5fd09b43424112868e9cc1706bca7","license":"MIT","urls":["bzz-raw://6df0ddf21ce9f58271bdfaa85cde98b200ef242a05a3f85c2bc10a8294800a92","dweb:/ipfs/QmRK2Y5Yc6BK7tGKkgsgn3aJEQGi5aakeSPZvS65PV8Xp3"]},"npm/openzeppelin-solidity@4.8.2/contracts/utils/math/Math.sol":{"keccak256":"0xbaf3bd8c64ac943fafde717797ee797c96360586b9448ea25e9872490a6e6858","license":"MIT","urls":["bzz-raw://bab65b9b5ea0c68e96e1a73460db616042f639d144a6a75595434cfa2a483ed4","dweb:/ipfs/QmUgwEcWXaEu4VSpymiVq8tZYKgA44HPMWZowpg2L8Kiij"]},"project/contracts/DexAggregator.sol":{"keccak256":"0xd2a49791875809c7a5c55ba0e13ba2ba14fe6611e474f3ba90c9ff3dab617ac7","license":"MIT","urls":["bzz-raw://5e9c0eb938beab7db502e24f905182ed1ee70708dcafe7f3c4864476f45710fe","dweb:/ipfs/Qmc5yDS1DxBBDAnwkZxt9MVJpt5vRSfmpw8nXSRXCuWZAm"]},"project/contracts/interfaces/IDexAggregator.sol":{"keccak256":"0x8a33871ec3eec31c69141b8271773c098d3e1e141bd63ae58397e4c4d3c08b9e","license":"MIT","urls":["bzz-raw://3b095e9808fa1529427b5c09c7c687b9b125764c84084732df3ce67014080133","dweb:/ipfs/Qmf8hNb5NST4sCy3p1BQCgjZwd2LE9kWN7ZBKGwLyKNemb"]},"project/contracts/interfaces/IWETH.sol":{"keccak256":"0x329f4e1ed8db5a2e5afb5e5deb08572962235c097fb62565474e6c86c00068bf","license":"MIT","urls":["bzz-raw://4d71ce6c783642ff2d3d04839ed138738705e37f91a0e323f6854ef99af139d1","dweb:/ipfs/QmSQxNyVXPUSjfrZndRHaWVPVmzRbkmCq55cd8a9VxxsKM"]},"project/contracts/libraries/LibAsset.sol":{"keccak256":"0x140c24edfe577c09a34644cd3f42a3d1566d0f07216bc906ffdfb64b67a70d1f","license":"MIT","urls":["bzz-raw://6a9e60ab10e03f37c5464c98acfcb77228fc097015e57770f047f1d4d1dcd221","dweb:/ipfs/QmYpwtSTjZX61JBF4H6mCdzuWvpGjT2Xwm5dXLFFDib7Wn"]},"project/contracts/libraries/LibRouter.sol":{"keccak256":"0xa0dc527d72ed0d0188cd77aca146844b5165405eb0f30a6ca1be3ca3e51179c7","license":"MIT","urls":["bzz-raw://7f660171e804c4191946d159370a099051cd4cd610c7ae7d08f55af476c2141c","dweb:/ipfs/QmRCUpnsh95id99RYsTrKJj6mZAx5MJPCvJuLWivZB6HoV"]}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_mapping(t_address,t_bool)":{"key":"t_address","label":"mapping(address => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_address","astId":7,"label":"_owner","offset":0,"contract":"project/contracts/DexAggregator.sol:DexAggregator"},{"slot":"1","type":"t_address","astId":120,"label":"_pendingOwner","offset":0,"contract":"project/contracts/DexAggregator.sol:DexAggregator"},{"slot":"1","type":"t_bool","astId":213,"label":"_paused","offset":20,"contract":"project/contracts/DexAggregator.sol:DexAggregator"},{"slot":"2","type":"t_mapping(t_address,t_bool)","astId":1561,"label":"internalCallers","offset":0,"contract":"project/contracts/DexAggregator.sol:DexAggregator"},{"slot":"3","type":"t_mapping(t_address,t_bool)","astId":1565,"label":"fundsManagers","offset":0,"contract":"project/contracts/DexAggregator.sol:DexAggregator"},{"slot":"4","type":"t_address","astId":1567,"label":"coreAddress","offset":0,"contract":"project/contracts/DexAggregator.sol:DexAggregator"},{"slot":"5","type":"t_address","astId":1569,"label":"weth","offset":0,"contract":"project/contracts/DexAggregator.sol:DexAggregator"}]},"transientStorageLayout":{"types":null,"storage":[]},"userdoc":{"kind":"user","methods":{},"version":1},"devdoc":{"kind":"dev","events":{"Paused(address)":{"details":"Emitted when the pause is triggered by `account`."},"Unpaused(address)":{"details":"Emitted when the pause is lifted by `account`."}},"methods":{"owner()":{"details":"Returns the address of the current owner."},"pause()":{"details":"See {IDexAggregator-pause}"},"paused()":{"details":"Returns true if the contract is paused, and false otherwise."},"unpause()":{"details":"See {IDexAggregator-unpause}"},"pendingOwner()":{"details":"Returns the address of the pending owner."},"acceptOwnership()":{"details":"The new owner accepts the ownership transfer."},"multicall(bytes[])":{"details":"See {IDexAggregator-multicall}"},"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."},"updateWeth(address)":{"details":"See {IDexAggregator-updateWeth}"},"estimateSwapGas(bytes)":{"details":"See {IDexAggregator-estimateSwapGas}"},"transferOwnership(address)":{"details":"Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one. Can only be called by the current owner."},"updateCoreAddress(address)":{"details":"See {IDexAggregator-updateCoreAddress}"},"updateAmountIn(bytes,uint256)":{"details":"See {IDexAggregator-updateAmountIn}"},"swapWithBackendSignature(bytes)":{"details":"See {IDexAggregator-swapWithBackendSignature}"},"updateFundsManager(address,bool)":{"details":"See {IDexAggregator-updateFundsManager}"},"updateInternalCaller(address,bool)":{"details":"See {IDexAggregator-updateInternalCaller}"},"transfer((address,address,uint256))":{"details":"See {IDexAggregator-transfer}"},"transferMany((address,address,uint256)[])":{"details":"See {IDexAggregator-transferMany}"}},"version":1},"sourceIds":{"project/contracts/DexAggregator.sol":{"id":6},"project/contracts/interfaces/IWETH.sol":{"id":8},"project/contracts/libraries/LibAsset.sol":{"id":9},"project/contracts/libraries/LibRouter.sol":{"id":10},"project/contracts/interfaces/IDexAggregator.sol":{"id":7},"npm/openzeppelin-solidity@4.8.2/contracts/utils/Address.sol":{"id":3},"npm/openzeppelin-solidity@4.8.2/contracts/utils/Context.sol":{"id":4},"npm/openzeppelin-solidity@4.8.2/contracts/access/Ownable.sol":{"id":0},"npm/openzeppelin-solidity@4.8.2/contracts/utils/math/Math.sol":{"id":5},"npm/openzeppelin-solidity@4.8.2/contracts/security/Pausable.sol":{"id":2},"npm/openzeppelin-solidity@4.8.2/contracts/access/Ownable2Step.sol":{"id":1}},"additionalInput":null,"stdJsonInput":{"sources":{"project/contracts/DexAggregator.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.28;\n\nimport {Ownable2Step} from \"openzeppelin-solidity/contracts/access/Ownable2Step.sol\";\nimport {Pausable} from \"openzeppelin-solidity/contracts/security/Pausable.sol\";\nimport {Address} from \"openzeppelin-solidity/contracts/utils/Address.sol\";\nimport {Math} from \"openzeppelin-solidity/contracts/utils/math/Math.sol\";\nimport {IDexAggregator} from \"./interfaces/IDexAggregator.sol\";\nimport {LibAsset} from \"./libraries/LibAsset.sol\";\nimport {LibRouter, SwapData} from \"./libraries/LibRouter.sol\";\n\nerror InvalidCall();\nerror InvalidCaller();\nerror InvalidFundManager();\nerror InsufficientAmountOut();\nerror InvalidNativeAmount();\n\ncontract DexAggregator is IDexAggregator, Ownable2Step, Pausable {\n    using LibAsset for address;\n\n    mapping(address => bool) public internalCallers;\n    mapping(address => bool) public fundsManagers;\n    address public coreAddress;\n    address public weth;\n\n    modifier onlyInternalCaller() {\n        if (!internalCallers[msg.sender]) {\n            revert InvalidCaller();\n        }\n        _;\n    }\n\n    modifier onlyFundManager() {\n        if (!fundsManagers[msg.sender]) {\n            revert InvalidFundManager();\n        }\n        _;\n    }\n\n    /// @dev See {IDexAggregator-updateInternalCaller}\n    function updateInternalCaller(address caller, bool value) external onlyOwner {\n        internalCallers[caller] = value;\n\n        emit UpdateInternalCaller(msg.sender, caller, value);\n    }\n\n    /// @dev See {IDexAggregator-updateFundsManager}\n    function updateFundsManager(address caller, bool value) external onlyOwner {\n        fundsManagers[caller] = value;\n\n        emit UpdateFundsManager(msg.sender, caller, value);\n    }\n\n    /// @dev See {IDexAggregator-updateCoreAddress}\n    function updateCoreAddress(address value) external onlyOwner {\n        coreAddress = value;\n    }\n\n    /// @dev See {IDexAggregator-updateWeth}\n    function updateWeth(address value) external onlyOwner {\n        weth = value;\n    }\n\n    /// @dev See {IDexAggregator-updateAmountIn}\n    function updateAmountIn(bytes memory data, uint256 amountIn) external pure returns (bytes memory) {\n        assembly {\n            mstore(add(data, 164), amountIn) // 32 + 132\n        }\n\n        return data;\n    }\n\n    /// @dev See {IDexAggregator-pause}\n    function pause() public onlyOwner whenNotPaused {\n        _pause();\n    }\n\n    /// @dev See {IDexAggregator-unpause}\n    function unpause() public onlyOwner whenPaused {\n        _unpause();\n    }\n\n    /// @dev See {IDexAggregator-transfer}\n    function transfer(TransferParam calldata transferParam) external onlyFundManager {\n        transferParam.assetAddress.transfer(transferParam.recipient, transferParam.amount);\n    }\n\n    /// @dev See {IDexAggregator-transferMany}\n    function transferMany(TransferParam[] calldata transferParams) external onlyFundManager {\n        for (uint256 i = 0; i < transferParams.length; ) {\n            transferParams[i].assetAddress.transfer(transferParams[i].recipient, transferParams[i].amount);\n            unchecked {\n                i++;\n            }\n        }\n    }\n\n    /// @dev See {IDexAggregator-multicall}\n    function multicall(bytes[] calldata data) external onlyOwner returns (bytes[] memory results) {\n        results = new bytes[](data.length);\n        for (uint256 i = 0; i < data.length; i++) {\n            results[i] = Address.functionDelegateCall(address(this), data[i]);\n        }\n        return results;\n    }\n\n    /// @dev Verifies the backend signature for a swap operation.\n    /// @param swapData The data structure containing information about the swap.\n    /// @return fromAddress The address to be used for the swap operation.\n    function verifyBackendSignature(SwapData memory swapData) private view returns (address fromAddress) {\n        bool hasSwapFee = swapData.swapFeeReceivers.length > 0;\n        uint256 messagePtr;\n        uint256 messageLength = hasSwapFee ? 480 : 384;\n        assembly {\n            messagePtr := mload(0x40)\n            mstore(0x40, add(messagePtr, messageLength))\n            switch hasSwapFee\n            case 1 {\n                // keccak256(\"Swap(address router,address sender,address recipient,address fromAsset,address toAsset,uint256 deadline,uint256 amountOutMin,uint256 expectedAmountOut,bytes32 consumerId,uint256 maxRetentionBps,bool transferFromRouter,address[] swapFeeAssets,address[] swapFeeReceivers,uint256[] swapFeeAmounts)\")\n                mstore(messagePtr, 0x5044c48dcff133da673c91c7d371f756e221fd81c7b9f02129fcfd724b840e49)\n            }\n            default {\n                // keccak256(\"Swap(address router,address sender,address recipient,address fromAsset,address toAsset,uint256 deadline,uint256 amountOutMin,uint256 expectedAmountOut,bytes32 consumerId,uint256 maxRetentionBps,bool transferFromRouter)\")\n                mstore(messagePtr, 0x088852e96193cda3374c3e36c04a8bd173e0c18999b51fb3f5c5ab52d7da1fe0)\n            }\n        }\n        fromAddress = LibRouter.verifySignature(\n            // keccak256(bytes(\"Dex Aggregator\")),\n            0x19994fa387947b8529d5d57c0c84137061b0be98f1cef929a4710ff4f36aed49,\n            // keccak256(bytes(\"1\")),\n            0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6,\n            swapData,\n            messagePtr,\n            messageLength,\n            2\n        );\n    }\n\n    function emitSwap(EmitSwapParams memory p) private {\n        emit Swap(\n            p.fromAddress,\n            p.toAddress,\n            p.fromAssetAddress,\n            p.toAssetAddress,\n            p.amountIn - (p.amountIn > p.transferredAmountIn ? p.amountIn - p.transferredAmountIn : 0),\n            p.amountOut,\n            p.expectedAmountOut,\n            p.amountIn > p.transferredAmountIn ? p.amountIn - p.transferredAmountIn : 0,\n            p.transferredAmountOut > p.amountOut ? p.transferredAmountOut - p.amountOut : 0,\n            p.consumerId,\n            p.swapFeeAssetAddresses,\n            p.swapFeeReceivers,\n            p.swapFeeAmounts\n        );\n    }\n\n    /// @dev Swaps tokens based on the provided swap data.\n    /// @param swapData The data structure containing information about the swap operation.\n    /// @param fromAddress The address initiating the swap. This address is responsible for the input assets.\n    /// @return amountOut The amount of tokens or assets received after the swap.\n    /// @return gasUsed The amount of gas consumed by the recorded operation.\n    function swap(\n        SwapData memory swapData,\n        address fromAddress,\n        address fromAssetAddress\n    ) private returns (uint256 amountOut, uint256 gasUsed) {\n        amountOut = swapData.toAssetAddress.getBalanceOf(swapData.toAddress);\n        uint256 transferredAmountOut = swapData.toAssetAddress.getBalance();\n        uint256 transferredAmountIn = swapData.amountIn;\n\n        adjustFromAssetAddress(swapData);\n\n        if (fromAssetAddress.isNative()) {\n            // Already transferred and wrapped\n            if (swapData.transferFromRouter) {\n                swapData.fromAssetAddress.approve(coreAddress, swapData.amountIn);\n            } else {\n                swapData.fromAssetAddress.transfer(coreAddress, swapData.amountIn);\n            }\n        } else {\n            if (swapData.transferFromRouter) {\n                swapData.fromAssetAddress.transferFrom(fromAddress, address(this), swapData.amountIn);\n                swapData.fromAssetAddress.approve(coreAddress, swapData.amountIn);\n            } else {\n                swapData.fromAssetAddress.transferFrom(fromAddress, coreAddress, swapData.amountIn);\n            }\n        }\n\n        address currentCoreAddress = coreAddress;\n        assembly {\n            let success := 0\n            let inputPtr := mload(0x40)\n            let inputLength := add(calldataload(36), 68)\n            let payloadLength := sub(inputLength, 68)\n            mstore(0x40, add(inputPtr, inputLength))\n            mstore(inputPtr, 0x158f689400000000000000000000000000000000000000000000000000000000) // swapWithoutSignature\n            mstore(add(inputPtr, 4), 32)\n            mstore(add(inputPtr, 36), payloadLength)\n            let outputPtr := mload(0x40)\n            mstore(0x40, add(outputPtr, 64))\n            calldatacopy(add(inputPtr, 68), 68, payloadLength)\n\n            // Override amountIn\n            mstore(add(inputPtr, 132), mload(add(swapData, 96)))\n\n            // Override fromAssetAddress\n            let afterFromAssetAddress := mload(add(inputPtr, 112))\n            mstore(add(inputPtr, 92), shl(96, mload(add(swapData, 32))))\n            mstore(add(inputPtr, 112), afterFromAssetAddress)\n\n            success := call(gas(), currentCoreAddress, 0, inputPtr, inputLength, outputPtr, 64)\n\n            if eq(success, 1) {\n                gasUsed := mload(outputPtr)\n            }\n\n            if eq(success, 0) {\n                returndatacopy(0, 0, returndatasize())\n                revert(0, returndatasize())\n            }\n        }\n\n        transferredAmountOut = swapData.toAssetAddress.getBalance() - transferredAmountOut;\n\n        if (swapData.transferFromRouter) {\n            // Slippage in fromAsset\n            swapData.toAssetAddress.transfer(swapData.toAddress, transferredAmountOut);\n            uint256 approval = swapData.fromAssetAddress.allowance(address(this), currentCoreAddress);\n            transferredAmountIn = swapData.amountIn - approval;\n            if (approval > 0) {\n                // Reset approval\n                swapData.fromAssetAddress.approve(currentCoreAddress, 0);\n            }\n        } else {\n            // Slippage in toAsset\n            swapData.toAssetAddress.transfer(\n                swapData.toAddress,\n                (transferredAmountOut <= swapData.expectedAmountOut || swapData.expectedAmountOut == 0)\n                    ? transferredAmountOut\n                    : Math.max(\n                        swapData.expectedAmountOut,\n                        transferredAmountOut - ((transferredAmountOut * swapData.maxRetentionBps) / 10000)\n                    )\n            );\n        }\n\n        amountOut = swapData.toAssetAddress.getBalanceOf(swapData.toAddress) - amountOut;\n\n        if (amountOut < swapData.amountOutMin) {\n            revert InsufficientAmountOut();\n        }\n\n        emitSwap(\n            EmitSwapParams({\n                fromAddress: fromAddress,\n                toAddress: swapData.toAddress,\n                fromAssetAddress: fromAssetAddress,\n                toAssetAddress: swapData.toAssetAddress,\n                transferredAmountIn: transferredAmountIn,\n                transferredAmountOut: transferredAmountOut,\n                amountIn: swapData.amountIn,\n                amountOut: amountOut,\n                expectedAmountOut: swapData.expectedAmountOut,\n                consumerId: swapData.consumerId,\n                swapFeeAssetAddresses: swapData.swapFeeAssetAddresses,\n                swapFeeReceivers: swapData.swapFeeReceivers,\n                swapFeeAmounts: swapData.swapFeeAmounts\n            })\n        );\n    }\n\n    function adjustFromAssetAddress(SwapData memory swapData) private {\n        if (swapData.fromAssetAddress.isNative()) {\n            swapData.fromAssetAddress = weth;\n            swapData.fromAssetAddress.wrap(swapData.amountIn);\n        }\n    }\n\n    function adjustAmountIn(SwapData memory swapData, uint256 transferredNativeFeeAmount) private {\n        // Auto\n        if (swapData.amountIn == 0) {\n            if (swapData.fromAssetAddress.isNative()) {\n                swapData.amountIn = msg.value - transferredNativeFeeAmount;\n            } else {\n                uint256 allowance = swapData.fromAssetAddress.allowance(msg.sender, address(this));\n                uint256 balance = swapData.fromAssetAddress.getBalanceOf(msg.sender);\n                swapData.amountIn = allowance < balance ? allowance : balance;\n            }\n        }\n\n        if (swapData.fromAssetAddress.isNative()) {\n            if (transferredNativeFeeAmount + swapData.amountIn != msg.value) {\n                revert InvalidNativeAmount();\n            }\n        } else {\n            if (transferredNativeFeeAmount != msg.value) {\n                revert InvalidNativeAmount();\n            }\n        }\n    }\n\n    /// @dev See {IDexAggregator-estimateSwapGas}\n    function estimateSwapGas(\n        bytes calldata\n    ) external payable whenNotPaused returns (uint256 amountOut, uint256 gasUsed) {\n        SwapData memory swapData = LibRouter.getData();\n        address fromAssetAddress = swapData.fromAssetAddress;\n        address fromAddress = verifyBackendSignature(swapData);\n        uint256 transferredNativeFeeAmount = LibRouter.transferFees(swapData, fromAddress);\n        adjustAmountIn(swapData, transferredNativeFeeAmount);\n        (amountOut, gasUsed) = swap(swapData, fromAddress, fromAssetAddress);\n    }\n\n    /// @dev See {IDexAggregator-swapWithBackendSignature}\n    function swapWithBackendSignature(bytes calldata) external payable whenNotPaused returns (uint256 amountOut) {\n        SwapData memory swapData = LibRouter.getData();\n        address fromAssetAddress = swapData.fromAssetAddress;\n        address fromAddress = verifyBackendSignature(swapData);\n        uint256 transferredNativeFeeAmount = LibRouter.transferFees(swapData, fromAddress);\n        adjustAmountIn(swapData, transferredNativeFeeAmount);\n        (amountOut, ) = swap(swapData, fromAddress, fromAssetAddress);\n    }\n\n    /// @dev Used to receive ethers\n    receive() external payable {}\n}\n"},"project/contracts/interfaces/IWETH.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.28;\n\ninterface IWETH {\n    function deposit() external payable;\n\n    function transfer(address to, uint256 value) external returns (bool);\n\n    function withdraw(uint256) external;\n}\n"},"project/contracts/libraries/LibAsset.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.28;\n\nimport \"../interfaces/IWETH.sol\";\n\nerror AssetNotReceived();\nerror ApprovalFailed();\nerror TransferFromFailed();\nerror TransferFailed();\nerror FailedWrap();\nerror FailedUnwrap();\n\nlibrary LibAsset {\n    using LibAsset for address;\n\n    address constant NATIVE_ASSETID = address(0);\n\n    /// @dev Checks if the given address (self) represents a native asset (Ether).\n    /// @param self The asset that will be checked for a native token.\n    /// @return Flag to identify if the asset is native or not.\n    function isNative(address self) internal pure returns (bool) {\n        return self == NATIVE_ASSETID;\n    }\n\n    /// @dev Wraps the specified asset.\n    /// @param self The asset that will be wrapped.\n    function wrap(address self, uint256 amount) internal {\n        uint256 ptr;\n        assembly {\n            ptr := mload(0x40)\n            mstore(0x40, add(ptr, 4))\n            mstore(ptr, 0xd0e30db000000000000000000000000000000000000000000000000000000000)\n        }\n\n        if (!execute(self, amount, ptr, 4, 0, 0)) {\n            revert FailedWrap();\n        }\n    }\n\n    /// @dev Unwraps the specified asset.\n    /// @param self The asset that will be unwrapped.\n    function unwrap(address self, uint256 amount) internal {\n        uint256 ptr;\n        assembly {\n            ptr := mload(0x40)\n            mstore(0x40, add(ptr, 36))\n            mstore(ptr, 0x2e1a7d4d00000000000000000000000000000000000000000000000000000000)\n            mstore(add(ptr, 4), amount)\n        }\n\n        if (!execute(self, 0, ptr, 36, 0, 0)) {\n            revert FailedUnwrap();\n        }\n    }\n\n    /// @dev Retrieves the balance of the current contract for a given asset (self).\n    /// @param self Asset whose balance needs to be found.\n    /// @return Balance of the specific asset.\n    function getBalance(address self) internal view returns (uint256) {\n        return getBalanceOf(self, address(this));\n    }\n\n    /// @dev Retrieves the balance of the target address for a given asset (self).\n    /// @param self Asset whose balance needs to be found.\n    /// @param targetAddress The address where the balance is checked from.\n    /// @return amount Balance of the specific asset.\n    function getBalanceOf(address self, address targetAddress) internal view returns (uint256 amount) {\n        assembly {\n            switch self\n            case 0 {\n                amount := balance(targetAddress)\n            }\n            default {\n                let currentInputPtr := mload(0x40)\n                mstore(0x40, add(currentInputPtr, 68))\n                mstore(currentInputPtr, 0x70a0823100000000000000000000000000000000000000000000000000000000)\n                mstore(add(currentInputPtr, 4), targetAddress)\n                let currentOutputPtr := add(currentInputPtr, 36)\n                if iszero(staticcall(gas(), self, currentInputPtr, 36, currentOutputPtr, 32)) {\n                    returndatacopy(0, 0, returndatasize())\n                    revert(0, returndatasize())\n                }\n\n                amount := mload(currentOutputPtr)\n            }\n        }\n    }\n\n    /// @dev Performs a safe transferFrom operation for a given asset (self) from one address (from) to another address (to).\n    /// @param self Asset that will be transferred.\n    /// @param from Address that will send the asset.\n    /// @param to Address that will receive the asset.\n    /// @param amount Transferred amount.\n    function transferFrom(address self, address from, address to, uint256 amount) internal {\n        uint256 ptr;\n        assembly {\n            ptr := mload(0x40)\n            mstore(0x40, add(ptr, 100))\n            mstore(ptr, 0x23b872dd00000000000000000000000000000000000000000000000000000000)\n            mstore(add(ptr, 4), from)\n            mstore(add(ptr, 36), to)\n            mstore(add(ptr, 68), amount)\n        }\n\n        if (!execute(self, 0, ptr, 100, 0, 0)) {\n            revert TransferFromFailed();\n        }\n    }\n\n    /// @dev Transfers a given amount of an asset (self) to a recipient address (recipient).\n    /// @param self Asset that will be transferred.\n    /// @param recipient Address that will receive the transferred asset.\n    /// @param amount Transferred amount.\n    function transfer(address self, address recipient, uint256 amount) internal {\n        if (self.isNative()) {\n            (bool success, ) = payable(recipient).call{value: amount}(\"\");\n            if (!success) {\n                revert TransferFailed();\n            }\n        } else {\n            uint256 ptr;\n            assembly {\n                ptr := mload(0x40)\n                mstore(0x40, add(ptr, 68))\n                mstore(ptr, 0xa9059cbb00000000000000000000000000000000000000000000000000000000)\n                mstore(add(ptr, 4), recipient)\n                mstore(add(ptr, 36), amount)\n            }\n            if (!execute(self, 0, ptr, 68, 0, 0)) {\n                revert TransferFailed();\n            }\n        }\n    }\n\n    /// @dev Approves a spender address (spender) to spend a specified amount of an asset (self).\n    /// @param self The asset that will be approved.\n    /// @param spender Address of a contract that will spend the owners asset.\n    /// @param amount Asset amount that can be spent.\n    function approve(address self, address spender, uint256 amount) internal {\n        uint256 ptr;\n        assembly {\n            ptr := mload(0x40)\n            mstore(0x40, add(ptr, 68))\n            mstore(ptr, 0x095ea7b300000000000000000000000000000000000000000000000000000000)\n            mstore(add(ptr, 4), spender)\n            mstore(add(ptr, 36), amount)\n        }\n\n        if (!execute(self, 0, ptr, 68, 0, 0)) {\n            assembly {\n                mstore(add(ptr, 36), 0)\n            }\n            if (!execute(self, 0, ptr, 68, 0, 0)) {\n                revert ApprovalFailed();\n            }\n            assembly {\n                mstore(add(ptr, 36), amount)\n            }\n            if (!execute(self, 0, ptr, 68, 0, 0)) {\n                revert ApprovalFailed();\n            }\n        }\n    }\n\n    /// @dev Returns the remaining number of tokens that spender is allowed to spend on behalf of owner.\n    /// @param self The asset that will be approved.\n    /// @param owner Address of a contract that will owner the asset.\n    /// @param spender Address of a contract that will spend the owners asset.\n    /// @return amount Asset amount that can be spent.\n    function allowance(address self, address owner, address spender) internal view returns (uint256 amount) {\n        uint256 currentInputPtr;\n        assembly {\n            currentInputPtr := mload(0x40)\n            mstore(0x40, add(currentInputPtr, 100))\n            mstore(currentInputPtr, 0xdd62ed3e00000000000000000000000000000000000000000000000000000000)\n            mstore(add(currentInputPtr, 4), owner)\n            mstore(add(currentInputPtr, 36), spender)\n            let currentOutputPtr := add(currentInputPtr, 68)\n            if iszero(staticcall(gas(), self, currentInputPtr, 68, currentOutputPtr, 32)) {\n                returndatacopy(0, 0, returndatasize())\n                revert(0, returndatasize())\n            }\n            if lt(returndatasize(), 32) {\n                revert(0, returndatasize())\n            }\n            amount := mload(currentOutputPtr)\n        }\n    }\n\n    /// @dev Executes a low level call.\n    function execute(\n        address self,\n        uint256 currentNativeAmount,\n        uint256 currentInputPtr,\n        uint256 currentInputLength,\n        uint256 currentOutputPtr,\n        uint256 outputLength\n    ) internal returns (bool result) {\n        assembly {\n            function isSuccessfulCall(targetAddress) -> isSuccessful {\n                switch iszero(returndatasize())\n                case 1 {\n                    if gt(extcodesize(targetAddress), 0) {\n                        isSuccessful := 1\n                    }\n                }\n                case 0 {\n                    returndatacopy(0, 0, 32)\n                    isSuccessful := gt(mload(0), 0)\n                }\n            }\n\n            if iszero(\n                call(\n                    gas(),\n                    self,\n                    currentNativeAmount,\n                    currentInputPtr,\n                    currentInputLength,\n                    currentOutputPtr,\n                    outputLength\n                )\n            ) {\n                returndatacopy(0, 0, returndatasize())\n                revert(0, returndatasize())\n            }\n\n            result := isSuccessfulCall(self)\n        }\n    }\n}\n"},"project/contracts/libraries/LibRouter.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.28;\n\nimport {LibAsset} from \"../libraries/LibAsset.sol\";\n\nstruct SwapData {\n    address toAddress;\n    address fromAssetAddress;\n    address toAssetAddress;\n    uint256 amountIn;\n    uint256 deadline;\n    uint256 amountOutMin;\n    uint256 expectedAmountOut;\n    bytes32 consumerId;\n    uint256 maxRetentionBps;\n    bool transferFromRouter;\n    address[] swapFeeAssetAddresses;\n    address[] swapFeeReceivers;\n    uint256[] swapFeeAmounts;\n}\n\nerror InvalidSignature();\nerror InvalidNativeFeeAmount();\nerror ExpiredTransaction();\n\nlibrary LibRouter {\n    using LibAsset for address;\n\n    /// @dev Prepares SwapData from calldata\n    function getData() internal view returns (SwapData memory swapData) {\n        uint256 swapFeeCount;\n        assembly {\n            swapFeeCount := shr(248, calldataload(274))\n        }\n\n        swapData.swapFeeAssetAddresses = new address[](swapFeeCount);\n        swapData.swapFeeReceivers = new address[](swapFeeCount);\n        swapData.swapFeeAmounts = new uint256[](swapFeeCount);\n\n        // dataOffset: 68 + 2\n        assembly {\n            // Fill\n            let deadline := shr(\n                shr(248, calldataload(164)), // dataOffset + 74\n                calldataload(shr(240, calldataload(165))) // dataOffset + 74 + 1\n            )\n\n            if lt(deadline, timestamp()) {\n                // ExpiredTransaction\n                mstore(0, 0x931997cf00000000000000000000000000000000000000000000000000000000)\n                revert(0, 4)\n            }\n\n            mstore(swapData, shr(96, calldataload(72))) // toAddress / dataOffset + 2\n            mstore(add(swapData, 32), shr(96, calldataload(92))) // fromAssetAddress\n            mstore(add(swapData, 64), shr(96, calldataload(112))) // toAssetAddress\n            mstore(add(swapData, 96), calldataload(132)) // amountIn\n            mstore(add(swapData, 128), deadline)\n            mstore(add(swapData, 160), shr(shr(248, calldataload(167)), calldataload(shr(240, calldataload(168))))) // amountOutMin\n            mstore(add(swapData, 192), shr(shr(248, calldataload(170)), calldataload(shr(240, calldataload(171))))) // expectedAmountOut\n            mstore(add(swapData, 224), calldataload(173)) // consumerId\n            mstore(add(swapData, 256), shr(shr(248, calldataload(205)), calldataload(shr(240, calldataload(206))))) // maxRetentionBps\n            mstore(add(swapData, 288), shr(248, calldataload(208))) // transferFromRouter\n            // calldataload(209) // r\n            // calldataload(241) // s\n            // shr(248, calldataload(273)) // v\n\n            let swapDataPtr := add(swapData, 416) // 320 + 96 Position placeholders\n            let callDataPtr := 275\n            for {\n                let i := 0\n            } lt(i, 3) {\n\n            } {\n                swapDataPtr := add(swapDataPtr, 32)\n                for {\n                    let j := 0\n                } lt(j, swapFeeCount) {\n\n                } {\n                    mstore(\n                        swapDataPtr,\n                        shr(\n                            shr(248, calldataload(callDataPtr)),\n                            calldataload(shr(240, calldataload(add(callDataPtr, 1))))\n                        )\n                    )\n                    j := add(j, 1)\n                    callDataPtr := add(callDataPtr, 3)\n                    swapDataPtr := add(swapDataPtr, 32)\n                }\n                i := add(i, 1)\n            }\n        }\n    }\n\n    /// @dev Transfers the required fees for the swap operation from the user's account.\n    /// @param swapData The data structure containing the details of the swap operation, including fee information.\n    /// @param fromAddress The address of the user from whom the fees will be deducted.\n    /// @return transferredNativeFeeAmount Total transferred fee amount in fromAssetAddress.\n    function transferFees(\n        SwapData memory swapData,\n        address fromAddress\n    ) internal returns (uint256 transferredNativeFeeAmount) {\n        uint256 swapFeeCount = swapData.swapFeeAmounts.length;\n        for (uint256 i = 0; i < swapFeeCount; ) {\n            address swapFeeAssetAddress = swapData.swapFeeAssetAddresses[i];\n            address swapFeeReceiver = swapData.swapFeeReceivers[i];\n            uint256 swapFeeAmount = swapData.swapFeeAmounts[i];\n            if (swapFeeAssetAddress.isNative()) {\n                swapFeeAssetAddress.transfer(swapFeeReceiver, swapFeeAmount);\n                transferredNativeFeeAmount += swapFeeAmount;\n            } else {\n                swapFeeAssetAddress.transferFrom(fromAddress, swapFeeReceiver, swapFeeAmount);\n            }\n            unchecked {\n                i++;\n            }\n        }\n    }\n\n    /// @dev Recovers the signer's address from a hashed message and signature components.\n    /// @param hash The hash of the message that was signed.\n    /// @param r The `r` component of the signature.\n    /// @param s The `s` component of the signature.\n    /// @param v The `v` component of the signature.\n    /// @return signer The address of the signer recovered from the signature.\n    function recoverSigner(bytes32 hash, bytes32 r, bytes32 s, uint8 v) private pure returns (address signer) {\n        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\n        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\n        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most\n        // signatures from current libraries generate a unique signature with an s-value in the lower half order.\n        //\n        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\n        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\n        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\n        // these malleable signatures as well.\n        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\n            revert InvalidSignature();\n        }\n        if (v != 27 && v != 28) {\n            revert InvalidSignature();\n        }\n\n        signer = ecrecover(hash, v, r, s);\n        if (signer == address(0)) {\n            revert InvalidSignature();\n        }\n    }\n\n    function getDomainSeparator(bytes32 name, bytes32 version) private view returns (bytes32) {\n        uint256 chainId;\n        assembly {\n            chainId := chainid()\n        }\n\n        return\n            keccak256(\n                abi.encode(\n                    // keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\")\n                    0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f,\n                    name,\n                    version,\n                    chainId,\n                    address(this)\n                )\n            );\n    }\n\n    /// @dev Verifies the signature for a swap operation.\n    /// @param swapData The SwapData struct containing swap details.\n    /// @param messagePtr Pointer to the message data in memory.\n    /// @param messageLength Length of the message data.\n    /// @param internalCallersSlot Slot in the internal callers storage for verification.\n    /// @return fromAddress The address of the signer / or caller if the signature is valid.\n    function verifySignature(\n        bytes32 name,\n        bytes32 version,\n        SwapData memory swapData,\n        uint256 messagePtr,\n        uint256 messageLength,\n        uint8 internalCallersSlot\n    ) internal view returns (address fromAddress) {\n        bytes32 domainSeparator = getDomainSeparator(name, version);\n        bytes32 digest;\n        bytes32 r;\n        bytes32 s;\n        uint8 v;\n        uint256 swapFeeCount = swapData.swapFeeReceivers.length;\n        assembly {\n            mstore(add(messagePtr, 32), address())\n            mstore(add(messagePtr, 64), caller())\n            mstore(add(messagePtr, 96), mload(swapData))\n            mstore(add(messagePtr, 128), mload(add(swapData, 32)))\n            mstore(add(messagePtr, 160), mload(add(swapData, 64)))\n            mstore(add(messagePtr, 192), mload(add(swapData, 128)))\n            mstore(add(messagePtr, 224), mload(add(swapData, 160)))\n            mstore(add(messagePtr, 256), mload(add(swapData, 192)))\n            mstore(add(messagePtr, 288), mload(add(swapData, 224)))\n            mstore(add(messagePtr, 320), mload(add(swapData, 256)))\n            mstore(add(messagePtr, 352), mload(add(swapData, 288)))\n\n            if gt(swapFeeCount, 0) {\n                mstore(add(messagePtr, 384), keccak256(add(swapData, 448), mul(swapFeeCount, 32)))\n                mstore(\n                    add(messagePtr, 416),\n                    keccak256(add(add(swapData, 448), mul(add(swapFeeCount, 1), 32)), mul(swapFeeCount, 32))\n                )\n                mstore(\n                    add(messagePtr, 448),\n                    keccak256(add(add(swapData, 448), mul(mul(add(swapFeeCount, 1), 32), 2)), mul(swapFeeCount, 32))\n                )\n            }\n            let hash := keccak256(messagePtr, messageLength)\n\n            messagePtr := mload(0x40)\n            mstore(0x40, add(messagePtr, 66))\n            mstore(messagePtr, \"\\x19\\x01\")\n            mstore(add(messagePtr, 2), domainSeparator)\n            mstore(add(messagePtr, 34), hash)\n            digest := keccak256(messagePtr, 66)\n\n            r := calldataload(209)\n            s := calldataload(241)\n            v := shr(248, calldataload(273))\n        }\n        address internalCaller = recoverSigner(digest, r, s, v);\n        assembly {\n            fromAddress := caller()\n            mstore(0, internalCaller)\n            mstore(0x20, internalCallersSlot)\n            if iszero(eq(sload(keccak256(0, 0x40)), 1)) {\n                // InvalidSignature\n                mstore(0, 0x8baa579f00000000000000000000000000000000000000000000000000000000)\n                revert(0, 4)\n            }\n        }\n    }\n}\n"},"project/contracts/interfaces/IDexAggregator.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.28;\n\ninterface IDexAggregator {\n    struct TransferParam {\n        address assetAddress;\n        address recipient;\n        uint256 amount;\n    }\n\n    event UpdateInternalCaller(address indexed sender, address caller, bool value);\n\n    /// @dev Allows the owner to update the whitelisted internal callers.\n    /// @param caller Caller address.\n    /// @param value Disable or enable the related caller.\n    function updateInternalCaller(address caller, bool value) external;\n\n    event UpdateFundsManager(address indexed sender, address caller, bool value);\n\n    /// @dev Allows the owner to update the whitelisted funds managers.\n    /// @param caller Caller address.\n    /// @param value Disable or enable the related caller.\n    function updateFundsManager(address caller, bool value) external;\n\n    /// @dev Allows the owner to update the magpire router core address.\n    /// @param value Core address.\n    function updateCoreAddress(address value) external;\n\n    /// @dev Allows the owner to update the weth address.\n    /// @param value WETH address.\n    function updateWeth(address value) external;\n\n    /// @dev Updates the input amount encoded within a bytes payload.\n    /// @param data The original encoded calldata or payload containing an amount value.\n    /// @param amountIn The new input amount to be inserted into the data payload.\n    /// @return bytes memory The modified data payload with the updated input amount.\n    function updateAmountIn(bytes memory data, uint256 amountIn) external returns (bytes memory);\n\n    /// @dev Called by the owner to pause, triggers stopped state.\n    function pause() external;\n\n    /// @dev Called by the owner to unpause, returns to normal state.\n    function unpause() external;\n\n    struct EmitSwapParams {\n        address fromAddress;\n        address toAddress;\n        address fromAssetAddress;\n        address toAssetAddress;\n        uint256 transferredAmountIn;\n        uint256 transferredAmountOut;\n        uint256 amountIn;\n        uint256 amountOut;\n        uint256 expectedAmountOut;\n        bytes32 consumerId;\n        address[] swapFeeAssetAddresses;\n        address[] swapFeeReceivers;\n        uint256[] swapFeeAmounts;\n    }\n\n    event Swap(\n        address fromAddress,\n        address toAddress,\n        address fromAssetAddress,\n        address toAssetAddress,\n        uint256 amountIn,\n        uint256 amountOut,\n        uint256 expectedAmountOut,\n        uint256 amountInSurplus,\n        uint256 amountOutSurplus,\n        bytes32 consumerId,\n        address[] swapFeeAssetAddresses,\n        address[] swapFeeReceivers,\n        uint256[] swapFeeAmounts\n    );\n\n    /// @dev Transfer asset from router to the recipient.\n    function transfer(TransferParam calldata transferParam) external;\n\n    /// @dev Transfer assets from router to the recipient.\n    function transferMany(TransferParam[] calldata transferParams) external;\n\n    /// @dev Makes it possible to execute multiple functions in the same transaction.\n    function multicall(bytes[] calldata data) external returns (bytes[] memory results);\n\n    /// @dev Provides an external interface to estimate the gas cost of the last hop in a route.\n    /// @return amountOut The amount received after swapping.\n    /// @return gasUsed The cost of gas while performing the swap.\n    function estimateSwapGas(bytes calldata swapArgs) external payable returns (uint256 amountOut, uint256 gasUsed);\n\n    /// @dev Performs token swap with magpie signature.\n    /// @return amountOut The amount received after swapping.\n    function swapWithBackendSignature(bytes calldata swapArgs) external payable returns (uint256 amountOut);\n}\n"},"npm/openzeppelin-solidity@4.8.2/contracts/utils/Address.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\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"},"npm/openzeppelin-solidity@4.8.2/contracts/utils/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (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"},"npm/openzeppelin-solidity@4.8.2/contracts/access/Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * 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"},"npm/openzeppelin-solidity@4.8.2/contracts/utils/math/Math.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n    enum Rounding {\n        Down, // Toward negative infinity\n        Up, // Toward infinity\n        Zero // Toward zero\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b) / 2 can overflow.\n        return (a & b) + (a ^ b) / 2;\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds up instead\n     * of rounding down.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b - 1) / b can overflow on addition, so we distribute.\n        return a == 0 ? 0 : (a - 1) / b + 1;\n    }\n\n    /**\n     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\n     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\n     * with further edits by Uniswap Labs also under MIT license.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\n        unchecked {\n            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\n            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n            // variables such that product = prod1 * 2^256 + prod0.\n            uint256 prod0; // Least significant 256 bits of the product\n            uint256 prod1; // Most significant 256 bits of the product\n            assembly {\n                let mm := mulmod(x, y, not(0))\n                prod0 := mul(x, y)\n                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\n            }\n\n            // Handle non-overflow cases, 256 by 256 division.\n            if (prod1 == 0) {\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n                // The surrounding unchecked block does not change this fact.\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n                return prod0 / denominator;\n            }\n\n            // Make sure the result is less than 2^256. Also prevents denominator == 0.\n            require(denominator > prod1, \"Math: mulDiv overflow\");\n\n            ///////////////////////////////////////////////\n            // 512 by 256 division.\n            ///////////////////////////////////////////////\n\n            // Make division exact by subtracting the remainder from [prod1 prod0].\n            uint256 remainder;\n            assembly {\n                // Compute remainder using mulmod.\n                remainder := mulmod(x, y, denominator)\n\n                // Subtract 256 bit number from 512 bit number.\n                prod1 := sub(prod1, gt(remainder, prod0))\n                prod0 := sub(prod0, remainder)\n            }\n\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\n            // See https://cs.stackexchange.com/q/138556/92363.\n\n            // Does not overflow because the denominator cannot be zero at this stage in the function.\n            uint256 twos = denominator & (~denominator + 1);\n            assembly {\n                // Divide denominator by twos.\n                denominator := div(denominator, twos)\n\n                // Divide [prod1 prod0] by twos.\n                prod0 := div(prod0, twos)\n\n                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\n                twos := add(div(sub(0, twos), twos), 1)\n            }\n\n            // Shift in bits from prod1 into prod0.\n            prod0 |= prod1 * twos;\n\n            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\n            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\n            // four bits. That is, denominator * inv = 1 mod 2^4.\n            uint256 inverse = (3 * denominator) ^ 2;\n\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\n            // in modular arithmetic, doubling the correct bits in each step.\n            inverse *= 2 - denominator * inverse; // inverse mod 2^8\n            inverse *= 2 - denominator * inverse; // inverse mod 2^16\n            inverse *= 2 - denominator * inverse; // inverse mod 2^32\n            inverse *= 2 - denominator * inverse; // inverse mod 2^64\n            inverse *= 2 - denominator * inverse; // inverse mod 2^128\n            inverse *= 2 - denominator * inverse; // inverse mod 2^256\n\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\n            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\n            // is no longer required.\n            result = prod0 * inverse;\n            return result;\n        }\n    }\n\n    /**\n     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\n        uint256 result = mulDiv(x, y, denominator);\n        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\n            result += 1;\n        }\n        return result;\n    }\n\n    /**\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\n     *\n     * Inspired by Henry S. Warren, Jr.'s \"Hacker's Delight\" (Chapter 11).\n     */\n    function sqrt(uint256 a) internal pure returns (uint256) {\n        if (a == 0) {\n            return 0;\n        }\n\n        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\n        //\n        // We know that the \"msb\" (most significant bit) of our target number `a` is a power of 2 such that we have\n        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\n        //\n        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\n        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\n        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\n        //\n        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\n        uint256 result = 1 << (log2(a) >> 1);\n\n        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\n        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\n        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\n        // into the expected uint128 result.\n        unchecked {\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            return min(result, a / result);\n        }\n    }\n\n    /**\n     * @notice Calculates sqrt(a), following the selected rounding direction.\n     */\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = sqrt(a);\n            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 128;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 64;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 32;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 16;\n            }\n            if (value >> 8 > 0) {\n                value >>= 8;\n                result += 8;\n            }\n            if (value >> 4 > 0) {\n                value >>= 4;\n                result += 4;\n            }\n            if (value >> 2 > 0) {\n                value >>= 2;\n                result += 2;\n            }\n            if (value >> 1 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log2(value);\n            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10 ** 64) {\n                value /= 10 ** 64;\n                result += 64;\n            }\n            if (value >= 10 ** 32) {\n                value /= 10 ** 32;\n                result += 32;\n            }\n            if (value >= 10 ** 16) {\n                value /= 10 ** 16;\n                result += 16;\n            }\n            if (value >= 10 ** 8) {\n                value /= 10 ** 8;\n                result += 8;\n            }\n            if (value >= 10 ** 4) {\n                value /= 10 ** 4;\n                result += 4;\n            }\n            if (value >= 10 ** 2) {\n                value /= 10 ** 2;\n                result += 2;\n            }\n            if (value >= 10 ** 1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log10(value);\n            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 256, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 16;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 8;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 4;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 2;\n            }\n            if (value >> 8 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log256(value);\n            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);\n        }\n    }\n}\n"},"npm/openzeppelin-solidity@4.8.2/contracts/security/Pausable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which allows children to implement an emergency stop\n * mechanism that can be triggered by an authorized account.\n *\n * This module is used through inheritance. It will make available the\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\n * the functions of your contract. Note that they will not be pausable by\n * simply including this module, only once the modifiers are put in place.\n */\nabstract contract Pausable is Context {\n    /**\n     * @dev Emitted when the pause is triggered by `account`.\n     */\n    event Paused(address account);\n\n    /**\n     * @dev Emitted when the pause is lifted by `account`.\n     */\n    event Unpaused(address account);\n\n    bool private _paused;\n\n    /**\n     * @dev Initializes the contract in unpaused state.\n     */\n    constructor() {\n        _paused = false;\n    }\n\n    /**\n     * @dev Modifier to make a function callable only when the contract is not paused.\n     *\n     * Requirements:\n     *\n     * - The contract must not be paused.\n     */\n    modifier whenNotPaused() {\n        _requireNotPaused();\n        _;\n    }\n\n    /**\n     * @dev Modifier to make a function callable only when the contract is paused.\n     *\n     * Requirements:\n     *\n     * - The contract must be paused.\n     */\n    modifier whenPaused() {\n        _requirePaused();\n        _;\n    }\n\n    /**\n     * @dev Returns true if the contract is paused, and false otherwise.\n     */\n    function paused() public view virtual returns (bool) {\n        return _paused;\n    }\n\n    /**\n     * @dev Throws if the contract is paused.\n     */\n    function _requireNotPaused() internal view virtual {\n        require(!paused(), \"Pausable: paused\");\n    }\n\n    /**\n     * @dev Throws if the contract is not paused.\n     */\n    function _requirePaused() internal view virtual {\n        require(paused(), \"Pausable: not paused\");\n    }\n\n    /**\n     * @dev Triggers stopped state.\n     *\n     * Requirements:\n     *\n     * - The contract must not be paused.\n     */\n    function _pause() internal virtual whenNotPaused {\n        _paused = true;\n        emit Paused(_msgSender());\n    }\n\n    /**\n     * @dev Returns to normal state.\n     *\n     * Requirements:\n     *\n     * - The contract must be paused.\n     */\n    function _unpause() internal virtual whenPaused {\n        _paused = false;\n        emit Unpaused(_msgSender());\n    }\n}\n"},"npm/openzeppelin-solidity@4.8.2/contracts/access/Ownable2Step.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (access/Ownable2Step.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./Ownable.sol\";\n\n/**\n * @dev Contract module which provides access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership} and {acceptOwnership}.\n *\n * This module is used through inheritance. It will make available all functions\n * from parent (Ownable).\n */\nabstract contract Ownable2Step is Ownable {\n    address private _pendingOwner;\n\n    event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Returns the address of the pending owner.\n     */\n    function pendingOwner() public view virtual returns (address) {\n        return _pendingOwner;\n    }\n\n    /**\n     * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual override onlyOwner {\n        _pendingOwner = newOwner;\n        emit OwnershipTransferStarted(owner(), newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual override {\n        delete _pendingOwner;\n        super._transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev The new owner accepts the ownership transfer.\n     */\n    function acceptOwnership() public virtual {\n        address sender = _msgSender();\n        require(pendingOwner() == sender, \"Ownable2Step: caller is not the new owner\");\n        _transferOwnership(sender);\n    }\n}\n"}},"language":"Solidity","settings":{"libraries":{},"optimizer":{"runs":200,"enabled":true},"evmVersion":"cancun","remappings":["project/:openzeppelin-solidity/=npm/openzeppelin-solidity@4.8.2/"]}},"stdJsonOutput":{"sources":{"project/contracts/DexAggregator.sol":{"id":6},"project/contracts/interfaces/IWETH.sol":{"id":8},"project/contracts/libraries/LibAsset.sol":{"id":9},"project/contracts/libraries/LibRouter.sol":{"id":10},"project/contracts/interfaces/IDexAggregator.sol":{"id":7},"npm/openzeppelin-solidity@4.8.2/contracts/utils/Address.sol":{"id":3},"npm/openzeppelin-solidity@4.8.2/contracts/utils/Context.sol":{"id":4},"npm/openzeppelin-solidity@4.8.2/contracts/access/Ownable.sol":{"id":0},"npm/openzeppelin-solidity@4.8.2/contracts/utils/math/Math.sol":{"id":5},"npm/openzeppelin-solidity@4.8.2/contracts/security/Pausable.sol":{"id":2},"npm/openzeppelin-solidity@4.8.2/contracts/access/Ownable2Step.sol":{"id":1}},"contracts":{"project/contracts/DexAggregator.sol":{"DexAggregator":{"abi":[{"name":"ApprovalFailed","type":"error","inputs":[]},{"name":"FailedWrap","type":"error","inputs":[]},{"name":"InsufficientAmountOut","type":"error","inputs":[]},{"name":"InvalidFundManager","type":"error","inputs":[]},{"name":"InvalidNativeAmount","type":"error","inputs":[]},{"name":"InvalidSignature","type":"error","inputs":[]},{"name":"TransferFailed","type":"error","inputs":[]},{"name":"TransferFromFailed","type":"error","inputs":[]},{"name":"OwnershipTransferStarted","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Paused","type":"event","inputs":[{"name":"account","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"Swap","type":"event","inputs":[{"name":"fromAddress","type":"address","indexed":false,"internalType":"address"},{"name":"toAddress","type":"address","indexed":false,"internalType":"address"},{"name":"fromAssetAddress","type":"address","indexed":false,"internalType":"address"},{"name":"toAssetAddress","type":"address","indexed":false,"internalType":"address"},{"name":"amountIn","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"amountOut","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"expectedAmountOut","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"amountInSurplus","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"amountOutSurplus","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"consumerId","type":"bytes32","indexed":false,"internalType":"bytes32"},{"name":"swapFeeAssetAddresses","type":"address[]","indexed":false,"internalType":"address[]"},{"name":"swapFeeReceivers","type":"address[]","indexed":false,"internalType":"address[]"},{"name":"swapFeeAmounts","type":"uint256[]","indexed":false,"internalType":"uint256[]"}],"anonymous":false},{"name":"Unpaused","type":"event","inputs":[{"name":"account","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"UpdateFundsManager","type":"event","inputs":[{"name":"sender","type":"address","indexed":true,"internalType":"address"},{"name":"caller","type":"address","indexed":false,"internalType":"address"},{"name":"value","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"UpdateInternalCaller","type":"event","inputs":[{"name":"sender","type":"address","indexed":true,"internalType":"address"},{"name":"caller","type":"address","indexed":false,"internalType":"address"},{"name":"value","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"acceptOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"coreAddress","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"estimateSwapGas","type":"function","inputs":[{"name":"","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"amountOut","type":"uint256","internalType":"uint256"},{"name":"gasUsed","type":"uint256","internalType":"uint256"}],"stateMutability":"payable"},{"name":"fundsManagers","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"internalCallers","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"multicall","type":"function","inputs":[{"name":"data","type":"bytes[]","internalType":"bytes[]"}],"outputs":[{"name":"results","type":"bytes[]","internalType":"bytes[]"}],"stateMutability":"nonpayable"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"pause","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"paused","type":"function","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"pendingOwner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"swapWithBackendSignature","type":"function","inputs":[{"name":"","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"amountOut","type":"uint256","internalType":"uint256"}],"stateMutability":"payable"},{"name":"transfer","type":"function","inputs":[{"name":"transferParam","type":"tuple","components":[{"name":"assetAddress","type":"address","internalType":"address"},{"name":"recipient","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"internalType":"struct IDexAggregator.TransferParam"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"transferMany","type":"function","inputs":[{"name":"transferParams","type":"tuple[]","components":[{"name":"assetAddress","type":"address","internalType":"address"},{"name":"recipient","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"internalType":"struct IDexAggregator.TransferParam[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"unpause","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateAmountIn","type":"function","inputs":[{"name":"data","type":"bytes","internalType":"bytes"},{"name":"amountIn","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bytes","internalType":"bytes"}],"stateMutability":"pure"},{"name":"updateCoreAddress","type":"function","inputs":[{"name":"value","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateFundsManager","type":"function","inputs":[{"name":"caller","type":"address","internalType":"address"},{"name":"value","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateInternalCaller","type":"function","inputs":[{"name":"caller","type":"address","internalType":"address"},{"name":"value","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateWeth","type":"function","inputs":[{"name":"value","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"weth","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"type":"receive","stateMutability":"payable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FailedWrap\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientAmountOut\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidFundManager\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidNativeAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSignature\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TransferFromFailed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferStarted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"Paused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"fromAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"toAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"fromAssetAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"toAssetAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"expectedAmountOut\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountInSurplus\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountOutSurplus\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"consumerId\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"swapFeeAssetAddresses\",\"type\":\"address[]\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"swapFeeReceivers\",\"type\":\"address[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"swapFeeAmounts\",\"type\":\"uint256[]\"}],\"name\":\"Swap\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"Unpaused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"name\":\"UpdateFundsManager\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"name\":\"UpdateInternalCaller\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"acceptOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"coreAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"estimateSwapGas\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"gasUsed\",\"type\":\"uint256\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"fundsManagers\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"internalCallers\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes[]\",\"name\":\"data\",\"type\":\"bytes[]\"}],\"name\":\"multicall\",\"outputs\":[{\"internalType\":\"bytes[]\",\"name\":\"results\",\"type\":\"bytes[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pause\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"paused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pendingOwner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"swapWithBackendSignature\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"assetAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"internalType\":\"struct IDexAggregator.TransferParam\",\"name\":\"transferParam\",\"type\":\"tuple\"}],\"name\":\"transfer\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"assetAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"internalType\":\"struct IDexAggregator.TransferParam[]\",\"name\":\"transferParams\",\"type\":\"tuple[]\"}],\"name\":\"transferMany\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"unpause\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"}],\"name\":\"updateAmountIn\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"value\",\"type\":\"address\"}],\"name\":\"updateCoreAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"name\":\"updateFundsManager\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"name\":\"updateInternalCaller\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"value\",\"type\":\"address\"}],\"name\":\"updateWeth\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"weth\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"events\":{\"Paused(address)\":{\"details\":\"Emitted when the pause is triggered by `account`.\"},\"Unpaused(address)\":{\"details\":\"Emitted when the pause is lifted by `account`.\"}},\"kind\":\"dev\",\"methods\":{\"acceptOwnership()\":{\"details\":\"The new owner accepts the ownership transfer.\"},\"estimateSwapGas(bytes)\":{\"details\":\"See {IDexAggregator-estimateSwapGas}\"},\"multicall(bytes[])\":{\"details\":\"See {IDexAggregator-multicall}\"},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"pause()\":{\"details\":\"See {IDexAggregator-pause}\"},\"paused()\":{\"details\":\"Returns true if the contract is paused, and false otherwise.\"},\"pendingOwner()\":{\"details\":\"Returns the address of the pending owner.\"},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner.\"},\"swapWithBackendSignature(bytes)\":{\"details\":\"See {IDexAggregator-swapWithBackendSignature}\"},\"transfer((address,address,uint256))\":{\"details\":\"See {IDexAggregator-transfer}\"},\"transferMany((address,address,uint256)[])\":{\"details\":\"See {IDexAggregator-transferMany}\"},\"transferOwnership(address)\":{\"details\":\"Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one. Can only be called by the current owner.\"},\"unpause()\":{\"details\":\"See {IDexAggregator-unpause}\"},\"updateAmountIn(bytes,uint256)\":{\"details\":\"See {IDexAggregator-updateAmountIn}\"},\"updateCoreAddress(address)\":{\"details\":\"See {IDexAggregator-updateCoreAddress}\"},\"updateFundsManager(address,bool)\":{\"details\":\"See {IDexAggregator-updateFundsManager}\"},\"updateInternalCaller(address,bool)\":{\"details\":\"See {IDexAggregator-updateInternalCaller}\"},\"updateWeth(address)\":{\"details\":\"See {IDexAggregator-updateWeth}\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/DexAggregator.sol\":\"DexAggregator\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[\"project/:openzeppelin-solidity/=npm/openzeppelin-solidity@4.8.2/\"]},\"sources\":{\"npm/openzeppelin-solidity@4.8.2/contracts/access/Ownable.sol\":{\"keccak256\":\"0x923b9774b81c1abfb992262ae7763b6e6de77b077a7180d53c6ebb7b1c8bd648\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://53445dc0431f9b45c06f567c6091da961d4087bec0010cca5bd62100fa624a38\",\"dweb:/ipfs/QmNvBYpBv183czrAqNXr76E8M3LF93ouAJFeAcHfb59Rcx\"]},\"npm/openzeppelin-solidity@4.8.2/contracts/access/Ownable2Step.sol\":{\"keccak256\":\"0x7cdab82b437a17902683a413c86d14f512674a0710007bf44c584a2d2d3ca833\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://ffe4db7a9f3cdd5a5d019462c2859f4f98f7aae08704afdcb3ef0d08d966bbeb\",\"dweb:/ipfs/QmTCHSuoi22dAu55qv4TcENyTmv5mTpAoxmYWD8cRnEp3M\"]},\"npm/openzeppelin-solidity@4.8.2/contracts/security/Pausable.sol\":{\"keccak256\":\"0x0849d93b16c9940beb286a7864ed02724b248b93e0d80ef6355af5ef15c64773\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://4ddabb16009cd17eaca3143feadf450ac13e72919ebe2ca50e00f61cb78bc004\",\"dweb:/ipfs/QmSPwPxX7d6TTWakN5jy5wsaGkS1y9TW8fuhGSraMkLk2B\"]},\"npm/openzeppelin-solidity@4.8.2/contracts/utils/Address.sol\":{\"keccak256\":\"0xa6dfb97ce947b7c846b054ee7d45d12383359778f4f3743654ae0a34fa421b26\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b97e7e5a77ea47c08ba422291df887eba76c80982f52a6e94a30106e9377a94f\",\"dweb:/ipfs/Qme7N2XRC7mcDxB8wZxNWPk6T8S2qsnmhAqXeUj4CNvsGD\"]},\"npm/openzeppelin-solidity@4.8.2/contracts/utils/Context.sol\":{\"keccak256\":\"0xe2e337e6dde9ef6b680e07338c493ebea1b5fd09b43424112868e9cc1706bca7\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://6df0ddf21ce9f58271bdfaa85cde98b200ef242a05a3f85c2bc10a8294800a92\",\"dweb:/ipfs/QmRK2Y5Yc6BK7tGKkgsgn3aJEQGi5aakeSPZvS65PV8Xp3\"]},\"npm/openzeppelin-solidity@4.8.2/contracts/utils/math/Math.sol\":{\"keccak256\":\"0xbaf3bd8c64ac943fafde717797ee797c96360586b9448ea25e9872490a6e6858\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://bab65b9b5ea0c68e96e1a73460db616042f639d144a6a75595434cfa2a483ed4\",\"dweb:/ipfs/QmUgwEcWXaEu4VSpymiVq8tZYKgA44HPMWZowpg2L8Kiij\"]},\"project/contracts/DexAggregator.sol\":{\"keccak256\":\"0xd2a49791875809c7a5c55ba0e13ba2ba14fe6611e474f3ba90c9ff3dab617ac7\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://5e9c0eb938beab7db502e24f905182ed1ee70708dcafe7f3c4864476f45710fe\",\"dweb:/ipfs/Qmc5yDS1DxBBDAnwkZxt9MVJpt5vRSfmpw8nXSRXCuWZAm\"]},\"project/contracts/interfaces/IDexAggregator.sol\":{\"keccak256\":\"0x8a33871ec3eec31c69141b8271773c098d3e1e141bd63ae58397e4c4d3c08b9e\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://3b095e9808fa1529427b5c09c7c687b9b125764c84084732df3ce67014080133\",\"dweb:/ipfs/Qmf8hNb5NST4sCy3p1BQCgjZwd2LE9kWN7ZBKGwLyKNemb\"]},\"project/contracts/interfaces/IWETH.sol\":{\"keccak256\":\"0x329f4e1ed8db5a2e5afb5e5deb08572962235c097fb62565474e6c86c00068bf\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://4d71ce6c783642ff2d3d04839ed138738705e37f91a0e323f6854ef99af139d1\",\"dweb:/ipfs/QmSQxNyVXPUSjfrZndRHaWVPVmzRbkmCq55cd8a9VxxsKM\"]},\"project/contracts/libraries/LibAsset.sol\":{\"keccak256\":\"0x140c24edfe577c09a34644cd3f42a3d1566d0f07216bc906ffdfb64b67a70d1f\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://6a9e60ab10e03f37c5464c98acfcb77228fc097015e57770f047f1d4d1dcd221\",\"dweb:/ipfs/QmYpwtSTjZX61JBF4H6mCdzuWvpGjT2Xwm5dXLFFDib7Wn\"]},\"project/contracts/libraries/LibRouter.sol\":{\"keccak256\":\"0xa0dc527d72ed0d0188cd77aca146844b5165405eb0f30a6ca1be3ca3e51179c7\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://7f660171e804c4191946d159370a099051cd4cd610c7ae7d08f55af476c2141c\",\"dweb:/ipfs/QmRCUpnsh95id99RYsTrKJj6mZAx5MJPCvJuLWivZB6HoV\"]}},\"version\":1}","userdoc":{"kind":"user","methods":{},"version":1},"devdoc":{"kind":"dev","events":{"Paused(address)":{"details":"Emitted when the pause is triggered by `account`."},"Unpaused(address)":{"details":"Emitted when the pause is lifted by `account`."}},"methods":{"owner()":{"details":"Returns the address of the current owner."},"pause()":{"details":"See {IDexAggregator-pause}"},"paused()":{"details":"Returns true if the contract is paused, and false otherwise."},"unpause()":{"details":"See {IDexAggregator-unpause}"},"pendingOwner()":{"details":"Returns the address of the pending owner."},"acceptOwnership()":{"details":"The new owner accepts the ownership transfer."},"multicall(bytes[])":{"details":"See {IDexAggregator-multicall}"},"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."},"updateWeth(address)":{"details":"See {IDexAggregator-updateWeth}"},"estimateSwapGas(bytes)":{"details":"See {IDexAggregator-estimateSwapGas}"},"transferOwnership(address)":{"details":"Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one. Can only be called by the current owner."},"updateCoreAddress(address)":{"details":"See {IDexAggregator-updateCoreAddress}"},"updateAmountIn(bytes,uint256)":{"details":"See {IDexAggregator-updateAmountIn}"},"swapWithBackendSignature(bytes)":{"details":"See {IDexAggregator-swapWithBackendSignature}"},"updateFundsManager(address,bool)":{"details":"See {IDexAggregator-updateFundsManager}"},"updateInternalCaller(address,bool)":{"details":"See {IDexAggregator-updateInternalCaller}"},"transfer((address,address,uint256))":{"details":"See {IDexAggregator-transfer}"},"transferMany((address,address,uint256)[])":{"details":"See {IDexAggregator-transferMany}"}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_mapping(t_address,t_bool)":{"key":"t_address","label":"mapping(address => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_address","astId":7,"label":"_owner","offset":0,"contract":"project/contracts/DexAggregator.sol:DexAggregator"},{"slot":"1","type":"t_address","astId":120,"label":"_pendingOwner","offset":0,"contract":"project/contracts/DexAggregator.sol:DexAggregator"},{"slot":"1","type":"t_bool","astId":213,"label":"_paused","offset":20,"contract":"project/contracts/DexAggregator.sol:DexAggregator"},{"slot":"2","type":"t_mapping(t_address,t_bool)","astId":1561,"label":"internalCallers","offset":0,"contract":"project/contracts/DexAggregator.sol:DexAggregator"},{"slot":"3","type":"t_mapping(t_address,t_bool)","astId":1565,"label":"fundsManagers","offset":0,"contract":"project/contracts/DexAggregator.sol:DexAggregator"},{"slot":"4","type":"t_address","astId":1567,"label":"coreAddress","offset":0,"contract":"project/contracts/DexAggregator.sol:DexAggregator"},{"slot":"5","type":"t_address","astId":1569,"label":"weth","offset":0,"contract":"project/contracts/DexAggregator.sol:DexAggregator"}]},"transientStorageLayout":{"types":null,"storage":[]},"evm":{"bytecode":{"object":"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","sourceMap":"684:12854:6:-:0;;;;;;;;;;;;-1:-1:-1;936:32:0;719:10:4;936:18:0;:32::i;:::-;996:7:2;:15;;-1:-1:-1;;;;996:15:2;;;684:12854:6;;1501:153:1;1590:13;1583:20;;-1:-1:-1;;;;;;1583:20:1;;;1613:34;1638:8;1613:24;:34::i;:::-;1501:153;:::o;2426:187:0:-;2499:16;2518:6;;-1:-1:-1;;;;;2534:17:0;;;-1:-1:-1;;;;;;2534:17:0;;;;;;2566:40;;2518:6;;;;;;;2566:40;;2499:16;2566:40;2489:124;2426:187;:::o;684:12854:6:-;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"684:12854:6:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1540:182;;;;;;;;;;-1:-1:-1;1540:182:6;;;;;:::i;:::-;;:::i;:::-;;1928:83;;;;;;;;;;-1:-1:-1;1928:83:6;;;;;:::i;:::-;;:::i;892:26::-;;;;;;;;;;-1:-1:-1;892:26:6;;;;-1:-1:-1;;;;;892:26:6;;;;;;-1:-1:-1;;;;;1008:32:11;;;990:51;;978:2;963:18;892:26:6;;;;;;;;1780:97;;;;;;;;;;-1:-1:-1;1780:97:6;;;;;:::i;:::-;;:::i;2446:74::-;;;;;;;;;;;;;:::i;924:19::-;;;;;;;;;;-1:-1:-1;924:19:6;;;;-1:-1:-1;;;;;924:19:6;;;12942:523;;;;;;:::i;:::-;;:::i;:::-;;;1789:25:11;;;1777:2;1762:18;12942:523:6;1643:177:11;1293:188:6;;;;;;;;;;-1:-1:-1;1293:188:6;;;;;:::i;:::-;;:::i;1615:84:2:-;;;;;;;;;;-1:-1:-1;1685:7:2;;-1:-1:-1;;;1685:7:2;;;;1615:84;;;1990:14:11;;1983:22;1965:41;;1953:2;1938:18;1615:84:2;1825:187:11;2802:331:6;;;;;;;;;;-1:-1:-1;2802:331:6;;;;;:::i;:::-;;:::i;788:47::-;;;;;;;;;;-1:-1:-1;788:47:6;;;;;:::i;:::-;;;;;;;;;;;;;;;;1824:101:0;;;;;;;;;;;;;:::i;1734:212:1:-;;;;;;;;;;;;;:::i;12325:552:6:-;;;;;;:::i;:::-;;:::i;:::-;;;;2842:25:11;;;2898:2;2883:18;;2876:34;;;;2815:18;12325:552:6;2668:248:11;2325:73:6;;;;;;;;;;;;;:::i;1201:85:0:-;;;;;;;;;;-1:-1:-1;1247:7:0;1273:6;-1:-1:-1;;;;;1273:6:0;1201:85;;2066:213:6;;;;;;;;;;-1:-1:-1;2066:213:6;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;841:45::-;;;;;;;;;;-1:-1:-1;841:45:6;;;;;:::i;:::-;;;;;;;;;;;;;;;;3183:310;;;;;;;;;;-1:-1:-1;3183:310:6;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;2569:180::-;;;;;;;;;;-1:-1:-1;2569:180:6;;;;;:::i;:::-;;:::i;847:99:1:-;;;;;;;;;;-1:-1:-1;926:13:1;;-1:-1:-1;;;;;926:13:1;847:99;;1139:178;;;;;;;;;;-1:-1:-1;1139:178:1;;;;;:::i;:::-;;:::i;1540:182:6:-;1094:13:0;:11;:13::i;:::-;-1:-1:-1;;;;;1625:21:6;::::1;;::::0;;;:13:::1;:21;::::0;;;;;;;;:29;;-1:-1:-1;;1625:29:6::1;::::0;::::1;;::::0;;::::1;::::0;;;1670:45;;6460:51:11;;;6527:18;;;6520:50;1689:10:6::1;::::0;1670:45:::1;::::0;6433:18:11;1670:45:6::1;;;;;;;;1540:182:::0;;:::o;1928:83::-;1094:13:0;:11;:13::i;:::-;1992:4:6::1;:12:::0;;-1:-1:-1;;;;;;1992:12:6::1;-1:-1:-1::0;;;;;1992:12:6;;;::::1;::::0;;;::::1;::::0;;1928:83::o;1780:97::-;1094:13:0;:11;:13::i;:::-;1851:11:6::1;:19:::0;;-1:-1:-1;;;;;;1851:19:6::1;-1:-1:-1::0;;;;;1851:19:6;;;::::1;::::0;;;::::1;::::0;;1780:97::o;2446:74::-;1094:13:0;:11;:13::i;:::-;1486:16:2::1;:14;:16::i;:::-;2503:10:6::2;:8;:10::i;:::-;2446:74::o:0;12942:523::-;13032:17;1239:19:2;:17;:19::i;:::-;13061:24:6::1;13088:19;:17;:19::i;:::-;13144:25;::::0;::::1;::::0;13061:46;;-1:-1:-1;13117:24:6::1;13201:32;13061:46:::0;13201:22:::1;:32::i;:::-;13179:54;;13243:34;13280:45;13303:8;13313:11;13280:22;:45::i;:::-;13243:82;;13335:52;13350:8;13360:26;13335:14;:52::i;:::-;13413:45;13418:8;13428:11;13441:16;13413:4;:45::i;:::-;-1:-1:-1::0;13397:61:6;12942:523;-1:-1:-1;;;;;;;12942:523:6:o;1293:188::-;1094:13:0;:11;:13::i;:::-;-1:-1:-1;;;;;1380:23:6;::::1;;::::0;;;:15:::1;:23;::::0;;;;;;;;:31;;-1:-1:-1;;1380:31:6::1;::::0;::::1;;::::0;;::::1;::::0;;;1427:47;;6460:51:11;;;6527:18;;;6520:50;1448:10:6::1;::::0;1427:47:::1;::::0;6433:18:11;1427:47:6::1;6292:284:11::0;2802:331:6;1150:10;1136:25;;;;:13;:25;;;;;;;;1131:84;;1184:20;;-1:-1:-1;;;1184:20:6;;;;;;;;;;;1131:84;2905:9:::1;2900:227;2920:25:::0;;::::1;2900:227;;;2963:94;3003:14;;3018:1;3003:17;;;;;;;:::i;:::-;;;;;;:27;;;;;;;;;;:::i;:::-;3032:14;;3047:1;3032:17;;;;;;;:::i;:::-;;;;;;:24;;;2963:14;;2978:1;2963:17;;;;;;;:::i;:::-;:30;::::0;::::1;:17;::::0;;::::1;;:30:::0;;::::1;::::0;-1:-1:-1;2963:30:6::1;:::i;:::-;-1:-1:-1::0;;;;;2963:39:6::1;::::0;:94;:39:::1;:94::i;:::-;3099:3;;2900:227;;;;2802:331:::0;;:::o;1824:101:0:-;1094:13;:11;:13::i;:::-;1888:30:::1;1915:1;1888:18;:30::i;1734:212:1:-:0;926:13;;719:10:4;;-1:-1:-1;;;;;926:13:1;1833:24;;1825:78;;;;-1:-1:-1;;;1825:78:1;;6915:2:11;1825:78:1;;;6897:21:11;6954:2;6934:18;;;6927:30;6993:34;6973:18;;;6966:62;-1:-1:-1;;;7044:18:11;;;7037:39;7093:19;;1825:78:1;;;;;;;;;1913:26;1932:6;1913:18;:26::i;:::-;1776:170;1734:212::o;12325:552:6:-;12420:17;12439:15;1239:19:2;:17;:19::i;:::-;12466:24:6::1;12493:19;:17;:19::i;:::-;12549:25;::::0;::::1;::::0;12466:46;;-1:-1:-1;12522:24:6::1;12606:32;12466:46:::0;12606:22:::1;:32::i;:::-;12584:54;;12648:34;12685:45;12708:8;12718:11;12685:22;:45::i;:::-;12648:82;;12740:52;12755:8;12765:26;12740:14;:52::i;:::-;12825:45;12830:8;12840:11;12853:16;12825:4;:45::i;:::-;12802:68:::0;;;;-1:-1:-1;12325:552:6;-1:-1:-1;;;;;;;12325:552:6:o;2325:73::-;1094:13:0;:11;:13::i;:::-;1239:19:2::1;:17;:19::i;:::-;2383:8:6::2;:6;:8::i;2066:213::-:0;2214:3;2204:14;;2197:32;;;2208:4;2066:213;;;;;:::o;3183:310::-;3253:22;1094:13:0;:11;:13::i;:::-;3309:4:6;-1:-1:-1;;;;;3297:24:6;::::1;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;3287:34:6;-1:-1:-1;3336:9:6::1;3331:132;3351:15:::0;;::::1;3331:132;;;3400:52;3437:4;3444;;3449:1;3444:7;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;3400:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;3400:28:6::1;::::0;-1:-1:-1;;;3400:52:6:i:1;:::-;3387:7;3395:1;3387:10;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;:65;3368:3:::1;;3331:132;;;;3183:310:::0;;;;:::o;2569:180::-;1150:10;1136:25;;;;:13;:25;;;;;;;;1131:84;;1184:20;;-1:-1:-1;;;1184:20:6;;;;;;;;;;;1131:84;2660:82:::1;2696:23;::::0;;;::::1;::::0;::::1;;:::i;:::-;2721:20;::::0;::::1;;2660:26;;::::0;::::1;2721:13:::0;2660:26:::1;:::i;1139:178:1:-:0;1094:13:0;:11;:13::i;:::-;1228::1::1;:24:::0;;-1:-1:-1;;;;;1228:24:1;::::1;-1:-1:-1::0;;;;;;1228:24:1;;::::1;::::0;::::1;::::0;;;1292:7:::1;1247::0::0;1273:6;-1:-1:-1;;;;;1273:6:0;;1201:85;1292:7:1::1;-1:-1:-1::0;;;;;1267:43:1::1;;;;;;;;;;;1139:178:::0;:::o;1359:130:0:-;1247:7;1273:6;-1:-1:-1;;;;;1273:6:0;719:10:4;1422:23:0;1414:68;;;;-1:-1:-1;;;1414:68:0;;7851:2:11;1414:68:0;;;7833:21:11;;;7870:18;;;7863:30;7929:34;7909:18;;;7902:62;7981:18;;1414:68:0;7649:356:11;1945:106:2;1685:7;;-1:-1:-1;;;1685:7:2;;;;2003:41;;;;-1:-1:-1;;;2003:41:2;;8212:2:11;2003:41:2;;;8194:21:11;8251:2;8231:18;;;8224:30;-1:-1:-1;;;8270:18:11;;;8263:50;8330:18;;2003:41:2;8010:344:11;2433:117:2;1486:16;:14;:16::i;:::-;2491:7:::1;:15:::0;;-1:-1:-1;;;;2491:15:2::1;::::0;;2521:22:::1;719:10:4::0;2530:12:2::1;2521:22;::::0;-1:-1:-1;;;;;1008:32:11;;;990:51;;978:2;963:18;2521:22:2::1;;;;;;;2433:117::o:0;1767:106::-;1685:7;;-1:-1:-1;;;1685:7:2;;;;1836:9;1828:38;;;;-1:-1:-1;;;1828:38:2;;8561:2:11;1828:38:2;;;8543:21:11;8600:2;8580:18;;;8573:30;-1:-1:-1;;;8619:18:11;;;8612:46;8675:18;;1828:38:2;8359:340:11;683:2819:10;725:24;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;725:24:10;852:3;839:17;834:3;830:27;;-1:-1:-1;;;;;910:27:10;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;910:27:10;-1:-1:-1;877:30:10;;;:60;989:12;-1:-1:-1;;;;;975:27:10;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;975:27:10;-1:-1:-1;947:25:10;;;:55;1052:12;-1:-1:-1;;;;;1038:27:10;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1038:27:10;-1:-1:-1;1012:23:10;;;:53;1285:3;1272:17;1267:3;1263:27;1250:41;1208:3;1195:17;1190:3;1186:27;1165:163;1358:11;1345:25;;1342:205;;;-1:-1:-1;;;1434:1:10;1427:77;1531:1;1528;1521:12;1342:205;1599:2;1586:16;1582:2;1578:25;1568:8;1561:43;1694:2;1681:16;1677:2;1673:25;1668:2;1658:8;1654:17;1647:52;1779:3;1766:17;1762:2;1758:26;1753:2;1743:8;1739:17;1732:53;1855:3;1842:17;1837:2;1827:8;1823:17;1816:44;1912:8;1906:3;1896:8;1892:18;1885:36;;2029:3;2016:17;2011:3;2007:27;1994:41;1987:3;1974:17;1969:3;1965:27;1961:75;1955:3;1945:8;1941:18;1934:103;2161:3;2148:17;2143:3;2139:27;2126:41;2119:3;2106:17;2101:3;2097:27;2093:75;2087:3;2077:8;2073:18;2066:103;2243:3;2230:17;2224:3;2214:8;2210:18;2203:45;2370:3;2357:17;2352:3;2348:27;2335:41;2328:3;2315:17;2310:3;2306:27;2302:75;2296:3;2286:8;2282:18;2275:103;2459:3;2446:17;2441:3;2437:27;2431:3;2421:8;2417:18;2410:55;2658:3;2648:8;2644:18;2728:3;2775:1;2744:742;2797:1;2794;2791:8;2744:742;;;2867:2;2854:11;2850:20;2835:35;;2922:1;2887:554;2948:12;2945:1;2942:19;2887:554;;;3224:1;3207:19;;;3194:33;3189:3;3185:43;3172:57;3116:25;;3111:3;3107:35;3074:181;3005:272;;3420:2;3403:20;;;;3365:1;3348:19;;;;3303:9;2887:554;;;-1:-1:-1;3470:1:10;3463:9;2744:742;;;2748:42;;;1115:2381;683:2819;:::o;3722:1661:6:-;3851:25;;;;:32;3802:19;;3851:36;;3802:19;;3851:36;3949:22;;3968:3;3949:22;;;3962:3;3949:22;3925:46;;;;4024:4;4018:11;4004:25;;4071:13;4059:10;4055:30;4049:4;4042:44;4106:10;4134:1;4129:452;;;;4890:66;4878:10;4871:86;4099:872;;4129:452;4500:66;4488:10;4481:86;4099:872;-1:-1:-1;5004:372:6;5094:66;5212;5292:8;5314:10;5338:13;5365:1;5004:25;:372::i;:::-;4990:386;3722:1661;-1:-1:-1;;;;;3722:1661:6:o;3894:862:10:-;4072:23;;;;:30;4003:34;;;4112:638;4136:12;4132:1;:16;4112:638;;;4166:27;4196:8;:30;;;4227:1;4196:33;;;;;;;;:::i;:::-;;;;;;;4166:63;;4243:23;4269:8;:25;;;4295:1;4269:28;;;;;;;;:::i;:::-;;;;;;;4243:54;;4311:21;4335:8;:23;;;4359:1;4335:26;;;;;;;;:::i;:::-;;;;;;;4311:50;;4379:30;:19;-1:-1:-1;;;;;4379:28:10;-1:-1:-1;;;;;640:22:9;;;562:107;4379:30:10;4375:306;;;4429:60;-1:-1:-1;;;;;4429:28:10;;4458:15;4475:13;4429:28;:60::i;:::-;4507:43;4537:13;4507:43;;:::i;:::-;;;4375:306;;;4589:77;-1:-1:-1;;;;;4589:32:10;;4622:11;4635:15;4652:13;4589:32;:77::i;:::-;-1:-1:-1;;;4722:3:10;;4112:638;;;;4039:717;3894:862;;;;:::o;11334:935:6:-;11458:8;:17;;;11479:1;11458:22;11454:471;;11500:25;;;;-1:-1:-1;;;;;11500:34:6;11496:419;;11576:38;11588:26;11576:9;:38;:::i;:::-;11556:17;;;:58;11496:419;;;11673:25;;;;11653:17;;11673:62;;-1:-1:-1;;;;;11673:35:6;11709:10;11729:4;11673:35;:62::i;:::-;11653:82;;11753:15;11771:50;11810:10;11771:8;:25;;;-1:-1:-1;;;;;11771:38:6;;;:50;;;;:::i;:::-;11753:68;;11871:7;11859:9;:19;:41;;11893:7;11859:41;;;11881:9;11859:41;11839:17;;;:61;-1:-1:-1;;11496:419:6;11939:25;;;;-1:-1:-1;;;;;11939:34:6;11935:328;;12045:9;12024:8;:17;;;11995:26;:46;;;;:::i;:::-;:59;11991:126;;12081:21;;-1:-1:-1;;;12081:21:6;;;;;;;;;;;11991:126;11334:935;;:::o;11935:328::-;12181:9;12151:26;:39;12147:106;;12217:21;;-1:-1:-1;;;12217:21:6;;;;;;;;;;;6486:4592;6620:17;6639:15;6678:56;6715:8;:18;;;6678:8;:23;;;-1:-1:-1;;;;;6678:36:6;;;:56;;;;:::i;:::-;6666:68;;6744:28;6775:36;:8;:23;;;-1:-1:-1;;;;;6775:34:6;;:36::i;:::-;6851:17;;;;6744:67;;-1:-1:-1;6879:32:6;6851:8;6879:22;:32::i;:::-;-1:-1:-1;;;;;6926:25:6;;6922:726;;7020:8;:27;;;7016:236;;;7101:11;;7114:17;;;;7067:25;;;;:65;;-1:-1:-1;;;;;7067:33:6;;;;7101:11;;;7067:33;:65::i;:::-;6922:726;;7016:236;7206:11;;7219:17;;;;7171:25;;;;:66;;-1:-1:-1;;;;;7171:34:6;;;;7206:11;;;7171:34;:66::i;6922:726::-;7286:8;:27;;;7282:356;;;7333:85;7372:11;7393:4;7400:8;:17;;;7333:8;:25;;;-1:-1:-1;;;;;7333:38:6;;;:85;;;;;;:::i;:::-;7470:11;;7483:17;;;;7436:25;;;;:65;;-1:-1:-1;;;;;7436:33:6;;;;7470:11;;;7436:33;:65::i;7282:356::-;7592:11;;7605:17;;;;7540:25;;;;:83;;-1:-1:-1;;;;;7540:38:6;;;;7579:11;;7592;;;;7540:38;:83::i;:::-;7658:26;7687:11;;;;;;;;;-1:-1:-1;;;;;7687:11:6;7658:40;;7746:1;7782:4;7776:11;7841:2;7836;7823:16;7819:25;7895:2;7882:11;7878:20;7938:11;7928:8;7924:26;7918:4;7911:40;-1:-1:-1;;;7971:8:6;7964:84;8110:2;8106:1;8096:8;8092:16;8085:28;8152:13;8147:2;8137:8;8133:17;8126:40;8202:4;8196:11;8248:2;8237:9;8233:18;8227:4;8220:32;8301:13;8297:2;8292;8282:8;8278:17;8265:50;8409:2;8399:8;8395:17;8389:24;8383:3;8373:8;8369:18;8362:52;8518:3;8508:8;8504:18;8498:25;8469:54;;8590:2;8580:8;8576:17;8570:24;8566:2;8562:33;8557:2;8547:8;8543:17;8536:60;8636:21;8630:3;8620:8;8616:18;8609:49;8752:2;8741:9;8728:11;8718:8;8715:1;8695:18;8688:5;8683:72;8672:83;;8784:1;8775:7;8772:14;8769:77;;8822:9;8816:16;8805:27;;8769:77;;;;;8875:1;8866:7;8863:14;8860:132;;8917:16;8914:1;8911;8896:38;8961:16;8958:1;8951:27;8860:132;;9074:20;9035:36;:8;:23;;;-1:-1:-1;;;;;9035:34:6;;:36::i;:::-;:59;;;;:::i;:::-;9012:82;;9109:8;:27;;;9105:999;;;9222:18;;9189:23;;;;:74;;-1:-1:-1;;;;;9189:32:6;;;;9242:20;9189:32;:74::i;:::-;9296:25;;;;9277:16;;9296:70;;-1:-1:-1;;;;;9296:35:6;9340:4;9347:18;9296:35;:70::i;:::-;9277:89;;9422:8;9402;:17;;;:28;;;;:::i;:::-;9380:50;-1:-1:-1;9448:12:6;;9444:141;;9514:25;;;;:56;;-1:-1:-1;;;;;9514:33:6;9548:18;9568:1;9514:33;:56::i;:::-;9138:457;9105:999;;;9650:443;9700:8;:18;;;9761:8;:26;;;9737:20;:50;;:85;;;-1:-1:-1;9791:26:6;;;;:31;9737:85;9736:343;;9889:190;9923:8;:26;;;10051:5;10023:8;:24;;;10000:20;:47;;;;:::i;:::-;9999:57;;;;:::i;:::-;9975:82;;:20;:82;:::i;:::-;9889:8;:190::i;:::-;9736:343;;;9846:20;9736:343;9650:23;;;;-1:-1:-1;;;;;9650:32:6;;:443;:32;:443::i;:::-;10163:18;;10126:23;;;;10185:9;;10126:56;;-1:-1:-1;;;;;10126:36:6;;;:56::i;:::-;:68;;;;:::i;:::-;10114:80;;10221:8;:21;;;10209:9;:33;10205:94;;;10265:23;;-1:-1:-1;;;10265:23:6;;;;;;;;;;;10205:94;10309:762;10331:730;;;;;;;;10377:11;-1:-1:-1;;;;;10331:730:6;;;;;10417:8;:18;;;-1:-1:-1;;;;;10331:730:6;;;;;10471:16;-1:-1:-1;;;;;10331:730:6;;;;;10521:8;:23;;;-1:-1:-1;;;;;10331:730:6;;;;;10583:19;10331:730;;;;10642:20;10331:730;;;;10690:8;:17;;;10331:730;;;;10736:9;10331:730;;;;10782:8;:26;;;10331:730;;;;10838:8;:19;;;10331:730;;;;10898:8;:30;;;10331:730;;;;10964:8;:25;;;10331:730;;;;11023:8;:23;;;10331:730;;;10309:8;:762::i;:::-;6656:4422;;;6486:4592;;;;;;:::o;4260:734:9:-;-1:-1:-1;;;;;4350:13:9;;4346:642;;4382:12;4408:9;-1:-1:-1;;;;;4400:23:9;4431:6;4400:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4381:61;;;4461:7;4456:70;;4495:16;;-1:-1:-1;;;4495:16:9;;;;;;;;;;;4456:70;4367:169;2900:227:6::1;2802:331:::0;;:::o;4346:642:9:-;4556:11;4621:4;4615:11;4608:18;;4665:2;4660:3;4656:12;4650:4;4643:26;-1:-1:-1;;;4693:3:9;4686:79;4802:9;4798:1;4793:3;4789:11;4782:30;4850:6;4845:2;4840:3;4836:12;4829:28;4889:31;4897:4;4903:1;4906:3;4911:2;4915:1;4918;4889:7;:31::i;:::-;4884:94;;4947:16;;-1:-1:-1;;;4947:16:9;;;;;;;;;;;1501:153:1;1590:13;1583:20;;-1:-1:-1;;;;;;1583:20:1;;;1613:34;1638:8;1613:24;:34::i;2186:115:2:-;1239:19;:17;:19::i;:::-;2255:4:::1;2245:14:::0;;-1:-1:-1;;;;2245:14:2::1;-1:-1:-1::0;;;2245:14:2::1;::::0;;2274:20:::1;2281:12;719:10:4::0;;640:96;6674:198:3;6757:12;6788:77;6809:6;6817:4;6788:77;;;;;;;;;;;;;;;;;:20;:77::i;:::-;6781:84;6674:198;-1:-1:-1;;;6674:198:3:o;7548:2644:10:-;6735:354;;;6886:66;6735:354;;;;12692:25:11;;;;12733:18;;;12726:34;;;12776:18;;;12769:34;;;6660:9:10;12819:18:11;;;12812:34;7066:4:10;12862:19:11;;;;12855:61;;;;6735:354:10;;;;;;;;;;12664:19:11;;;;6735:354:10;;;6708:395;;;;;7777:19;;7877:14;7901:9;7920;7939:7;7956:20;7979:8;:25;;;:32;7956:55;;8072:9;8067:2;8055:10;8051:19;8044:38;8123:8;8118:2;8106:10;8102:19;8095:37;8179:8;8173:15;8168:2;8156:10;8152:19;8145:44;8251:2;8241:8;8237:17;8231:24;8225:3;8213:10;8209:20;8202:54;8318:2;8308:8;8304:17;8298:24;8292:3;8280:10;8276:20;8269:54;8385:3;8375:8;8371:18;8365:25;8359:3;8347:10;8343:20;8336:55;8453:3;8443:8;8439:18;8433:25;8427:3;8415:10;8411:20;8404:55;8521:3;8511:8;8507:18;8501:25;8495:3;8483:10;8479:20;8472:55;8589:3;8579:8;8575:18;8569:25;8563:3;8551:10;8547:20;8540:55;8657:3;8647:8;8643:18;8637:25;8631:3;8619:10;8615:20;8608:55;8725:3;8715:8;8711:18;8705:25;8699:3;8687:10;8683:20;8676:55;8765:1;8751:12;8748:19;8745:531;;;8863:2;8845:21;;;8839:3;8825:18;;;8815:52;;;8809:3;8793:20;;8786:82;9011:1;8993:20;;8989:29;;;8965:54;;;;8955:88;;;8929:3;8913:20;;8885:176;9182:37;;;;9158:62;;;;9148:96;9106:20;;;9078:184;8745:531;9323:13;9311:10;9301:36;9371:4;9365:11;9351:25;;9418:2;9406:10;9402:19;9396:4;9389:33;-1:-1:-1;;;9442:10:10;9435:30;9505:15;9501:1;9489:10;9485:18;9478:43;9562:4;9557:2;9545:10;9541:19;9534:33;;9612:2;9600:10;9590:25;9580:35;;9647:3;9634:17;9629:22;;9682:3;9669:17;9664:22;;9726:3;9713:17;9708:3;9704:27;9699:32;;9750:22;9775:30;9789:6;9797:1;9800;9803;9775:13;:30::i;:::-;9750:55;;9853:8;9838:23;;9884:14;9881:1;9874:25;9925:19;9919:4;9912:33;9998:1;9990:4;9987:1;9977:18;9971:25;9968:32;9958:218;;-1:-1:-1;;;10063:1:10;10056:77;10160:1;10157;10150:12;9958:218;9824:362;;;;;;;7548:2644;;;;;;;;:::o;3469:524:9:-;3566:11;3623:4;3617:11;3610:18;;3663:3;3658;3654:13;3648:4;3641:27;-1:-1:-1;;;3688:3:9;3681:79;3793:4;3789:1;3784:3;3780:11;3773:25;3832:2;3827;3822:3;3818:12;3811:24;3869:6;3864:2;3859:3;3855:12;3848:28;3901:32;3909:4;3915:1;3918:3;3923;3928:1;3931;3901:7;:32::i;:::-;3896:91;;3956:20;;-1:-1:-1;;;3956:20:9;;;;;;;;;;;3896:91;3556:437;3469:524;;;;:::o;6458:889::-;6546:14;6572:23;6653:4;6647:11;6628:30;;6705:3;6688:15;6684:25;6678:4;6671:39;-1:-1:-1;;;6730:15:9;6723:91;6859:5;6855:1;6838:15;6834:23;6827:38;6911:7;6906:2;6889:15;6885:24;6878:41;6977:2;6960:15;6956:24;7066:2;7048:16;7044:2;7027:15;7021:4;7014:5;7003:66;6993:192;;7110:16;7107:1;7104;7089:38;7154:16;7151:1;7144:27;6993:192;7222:2;7204:16;7201:24;7198:87;;;7254:16;7251:1;7244:27;7198:87;7308:23;;6458:889;-1:-1:-1;;;;;6458:889:9:o;2242:892::-;2324:14;2380:4;2397:71;;;;2536:4;2530:11;2592:2;2575:15;2571:24;2565:4;2558:38;-1:-1:-1;;;2620:15:9;2613:91;2753:13;2749:1;2732:15;2728:23;2721:46;2829:2;2812:15;2808:24;2922:2;2904:16;2900:2;2883:15;2877:4;2870:5;2859:66;2849:204;;2970:16;2967:1;2964;2949:38;3018:16;3015:1;3008:27;2849:204;3081:23;;-1:-1:-1;2373:745:9;;-1:-1:-1;2373:745:9;2397:71;-1:-1:-1;;2432:22:9;;2242:892;-1:-1:-1;2242:892:9:o;1841:123::-;1898:7;1924:33;1937:4;1951;1924:12;:33::i;11084:244:6:-;11164:25;;;;-1:-1:-1;;;;;11164:34:6;11160:162;;11244:4;;-1:-1:-1;;;;;11244:4:6;11216:25;;;:32;;;11293:17;;;;11262:49;;11244:4;11262:30;:49::i;5284:806:9:-;5367:11;5424:4;5418:11;5411:18;;5464:2;5459:3;5455:12;5449:4;5442:26;-1:-1:-1;;;5488:3:9;5481:79;5593:7;5589:1;5584:3;5580:11;5573:28;5635:6;5630:2;5625:3;5621:12;5614:28;5667:31;5675:4;5681:1;5684:3;5689:2;5693:1;5696;5667:7;:31::i;:::-;5662:422;;5762:1;5757:2;5752:3;5748:12;5741:23;5796:31;5804:4;5810:1;5813:3;5818:2;5822:1;5825;5796:7;:31::i;:::-;5791:94;;5854:16;;-1:-1:-1;;;5854:16:9;;;;;;;;;;;5791:94;5946:6;5941:2;5936:3;5932:12;5925:28;5985:31;5993:4;5999:1;6002:3;6007:2;6011:1;6014;5985:7;:31::i;:::-;5980:94;;6043:16;;-1:-1:-1;;;6043:16:9;;;;;;;;;;;413:104:5;471:7;501:1;497;:5;:13;;509:1;497:13;;;-1:-1:-1;505:1:5;;413:104;-1:-1:-1;413:104:5:o;5389:670:6:-;5455:597;5473:1;:13;;;5500:1;:11;;;5525:1;:18;;;5557:1;:16;;;5614:1;:21;;;5601:1;:10;;;:34;:75;;5675:1;5601:75;;;5651:1;:21;;;5638:1;:10;;;:34;;;;:::i;:::-;5587:1;:10;;;:90;;;;:::i;:::-;5691:1;:11;;;5716:1;:19;;;5762:1;:21;;;5749:1;:10;;;:34;:75;;5823:1;5749:75;;;5799:1;:21;;;5786:1;:10;;;:34;;;;:::i;:::-;5863:1;:11;;;5838:1;:22;;;:36;:79;;5916:1;5838:79;;;5902:1;:11;;;5877:1;:22;;;:36;;;;:::i;:::-;5931:1;:12;;;5957:1;:23;;;5994:1;:18;;;6026:1;:16;;;5455:597;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;5389:670;:::o;7393:1202:9:-;7626:11;7672:426;;;7716:12;7761:16;7754:24;7800:1;7795:149;;;;7961:123;;;;7747:337;;7795:149;7830:26;;7827:33;7824:102;;7903:1;7887:17;;7824:102;7795:149;;7961:123;8011:2;8008:1;8005;7990:24;8064:1;8060;8054:8;8051:15;8035:31;;7747:337;;7672:426;;;:::o;:::-;8374:12;8336:16;8296:18;8259:15;8218:19;8192:4;8165:5;8139:265;8112:421;;8458:16;8455:1;8452;8437:38;8502:16;8499:1;8492:27;8112:421;8557:22;8574:4;8557:22;:::i;:::-;8547:32;7393:1202;-1:-1:-1;;;;;;;7393:1202:9:o;2426:187:0:-;2499:16;2518:6;;-1:-1:-1;;;;;2534:17:0;;;-1:-1:-1;;;;;;2534:17:0;;;;;;2566:40;;2518:6;;;;;;;2566:40;;2499:16;2566:40;2489:124;2426:187;:::o;7058:325:3:-;7199:12;7224;7238:23;7265:6;-1:-1:-1;;;;;7265:19:3;7285:4;7265:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7223:67;;;;7307:69;7334:6;7342:7;7351:10;7363:12;7307:26;:69::i;:::-;7300:76;7058:325;-1:-1:-1;;;;;;7058:325:3:o;5152:1343:10:-;5242:14;6159:66;6146:79;;6142:135;;;6248:18;;-1:-1:-1;;;6248:18:10;;;;;;;;;;;6142:135;6290:1;:7;;6295:2;6290:7;;:18;;;;;6301:1;:7;;6306:2;6301:7;;6290:18;6286:74;;;6331:18;;-1:-1:-1;;;6331:18:10;;;;;;;;;;;6286:74;6379:24;;;;;;;;;;;;13154:25:11;;;13227:4;13215:17;;13195:18;;;13188:45;;;;13249:18;;;13242:34;;;13292:18;;;13285:34;;;6379:24:10;;13126:19:11;;6379:24:10;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;6379:24:10;;-1:-1:-1;;6379:24:10;;;-1:-1:-1;;;;;;;6417:20:10;;6413:76;;6460:18;;-1:-1:-1;;;6460:18:10;;;;;;;;;;;6413:76;5152:1343;;;;;;:::o;767:367:9:-;830:11;887:4;881:11;874:18;;927:1;922:3;918:11;912:4;905:25;-1:-1:-1;;;950:3:9;943:79;1047:35;1055:4;1061:6;1069:3;1074:1;1077;1080;1047:7;:35::i;:::-;1042:86;;1105:12;;-1:-1:-1;;;1105:12:9;;;;;;;;;;;7671:628:3;7851:12;7879:7;7875:418;;;7906:10;:17;7927:1;7906:22;7902:286;;-1:-1:-1;;;;;1702:19:3;;;8113:60;;;;-1:-1:-1;;;8113:60:3;;13532:2:11;8113:60:3;;;13514:21:11;13571:2;13551:18;;;13544:30;13610:31;13590:18;;;13583:59;13659:18;;8113:60:3;13330:353:11;8113:60:3;-1:-1:-1;8208:10:3;8201:17;;7875:418;8249:33;8257:10;8269:12;8980:17;;:21;8976:379;;9208:10;9202:17;9264:15;9251:10;9247:2;9243:19;9236:44;8976:379;9331:12;9324:20;;-1:-1:-1;;;9324:20:3;;;;;;;;:::i;14:173:11:-;82:20;;-1:-1:-1;;;;;131:31:11;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:347::-;257:6;265;318:2;306:9;297:7;293:23;289:32;286:52;;;334:1;331;324:12;286:52;357:29;376:9;357:29;:::i;:::-;347:39;;436:2;425:9;421:18;408:32;483:5;476:13;469:21;462:5;459:32;449:60;;505:1;502;495:12;449:60;528:5;518:15;;;192:347;;;;;:::o;544:186::-;603:6;656:2;644:9;635:7;631:23;627:32;624:52;;;672:1;669;662:12;624:52;695:29;714:9;695:29;:::i;1052:586::-;1122:6;1130;1183:2;1171:9;1162:7;1158:23;1154:32;1151:52;;;1199:1;1196;1189:12;1151:52;1239:9;1226:23;-1:-1:-1;;;;;1264:6:11;1261:30;1258:50;;;1304:1;1301;1294:12;1258:50;1327:22;;1380:4;1372:13;;1368:27;-1:-1:-1;1358:55:11;;1409:1;1406;1399:12;1358:55;1449:2;1436:16;-1:-1:-1;;;;;1467:6:11;1464:30;1461:50;;;1507:1;1504;1497:12;1461:50;1552:7;1547:2;1538:6;1534:2;1530:15;1526:24;1523:37;1520:57;;;1573:1;1570;1563:12;1520:57;1604:2;1596:11;;;;;1626:6;;-1:-1:-1;1052:586:11;-1:-1:-1;;;1052:586:11:o;2017:646::-;2136:6;2144;2197:2;2185:9;2176:7;2172:23;2168:32;2165:52;;;2213:1;2210;2203:12;2165:52;2253:9;2240:23;-1:-1:-1;;;;;2278:6:11;2275:30;2272:50;;;2318:1;2315;2308:12;2272:50;2341:22;;2394:4;2386:13;;2382:27;-1:-1:-1;2372:55:11;;2423:1;2420;2413:12;2372:55;2463:2;2450:16;-1:-1:-1;;;;;2481:6:11;2478:30;2475:50;;;2521:1;2518;2511:12;2475:50;2577:7;2572:2;2564:4;2556:6;2552:17;2548:2;2544:26;2540:35;2537:48;2534:68;;;2598:1;2595;2588:12;2921:127;2982:10;2977:3;2973:20;2970:1;2963:31;3013:4;3010:1;3003:15;3037:4;3034:1;3027:15;3053:1068;3130:6;3138;3191:2;3179:9;3170:7;3166:23;3162:32;3159:52;;;3207:1;3204;3197:12;3159:52;3247:9;3234:23;-1:-1:-1;;;;;3272:6:11;3269:30;3266:50;;;3312:1;3309;3302:12;3266:50;3335:22;;3388:4;3380:13;;3376:27;-1:-1:-1;3366:55:11;;3417:1;3414;3407:12;3366:55;3457:2;3444:16;-1:-1:-1;;;;;3475:6:11;3472:30;3469:56;;;3505:18;;:::i;:::-;3554:2;3548:9;3646:2;3608:17;;-1:-1:-1;;3604:31:11;;;3637:2;3600:40;3596:54;3584:67;;-1:-1:-1;;;;;3666:34:11;;3702:22;;;3663:62;3660:88;;;3728:18;;:::i;:::-;3764:2;3757:22;3788;;;3829:15;;;3846:4;3825:26;3822:39;-1:-1:-1;3819:59:11;;;3874:1;3871;3864:12;3819:59;3934:6;3927:4;3923:2;3919:13;3912:4;3904:6;3900:17;3887:54;3989:1;3982:4;3961:19;;;3957:30;;3950:41;3961:19;4070:20;;4057:34;;-1:-1:-1;;;;3053:1068:11:o;4126:288::-;4167:3;4205:5;4199:12;4232:6;4227:3;4220:19;4288:6;4281:4;4274:5;4270:16;4263:4;4258:3;4254:14;4248:47;4340:1;4333:4;4324:6;4319:3;4315:16;4311:27;4304:38;4403:4;4396:2;4392:7;4387:2;4379:6;4375:15;4371:29;4366:3;4362:39;4358:50;4351:57;;;4126:288;;;;:::o;4419:217::-;4566:2;4555:9;4548:21;4529:4;4586:44;4626:2;4615:9;4611:18;4603:6;4586:44;:::i;4641:621::-;4738:6;4746;4799:2;4787:9;4778:7;4774:23;4770:32;4767:52;;;4815:1;4812;4805:12;4767:52;4855:9;4842:23;-1:-1:-1;;;;;4880:6:11;4877:30;4874:50;;;4920:1;4917;4910:12;4874:50;4943:22;;4996:4;4988:13;;4984:27;-1:-1:-1;4974:55:11;;5025:1;5022;5015:12;4974:55;5065:2;5052:16;-1:-1:-1;;;;;5083:6:11;5080:30;5077:50;;;5123:1;5120;5113:12;5077:50;5176:7;5171:2;5161:6;5158:1;5154:14;5150:2;5146:23;5142:32;5139:45;5136:65;;;5197:1;5194;5187:12;5267:779;5427:4;5475:2;5464:9;5460:18;5505:2;5494:9;5487:21;5528:6;5563;5557:13;5594:6;5586;5579:22;5632:2;5621:9;5617:18;5610:25;;5694:2;5684:6;5681:1;5677:14;5666:9;5662:30;5658:39;5644:53;;5732:2;5724:6;5720:15;5753:1;5763:254;5777:6;5774:1;5771:13;5763:254;;;5870:2;5866:7;5854:9;5846:6;5842:22;5838:36;5833:3;5826:49;5898:39;5930:6;5921;5915:13;5898:39;:::i;:::-;5888:49;-1:-1:-1;5972:2:11;5995:12;;;;5960:15;;;;;5799:1;5792:9;5763:254;;;-1:-1:-1;6034:6:11;;5267:779;-1:-1:-1;;;;;;5267:779:11:o;6051:236::-;6143:6;6203:2;6191:9;6182:7;6178:23;6174:32;6218:2;6215:22;;;6233:1;6230;6223:12;6215:22;-1:-1:-1;6272:9:11;;6051:236;-1:-1:-1;;6051:236:11:o;6581:127::-;6642:10;6637:3;6633:20;6630:1;6623:31;6673:4;6670:1;6663:15;6697:4;6694:1;6687:15;7123:521;7200:4;7206:6;7266:11;7253:25;7360:2;7356:7;7345:8;7329:14;7325:29;7321:43;7301:18;7297:68;7287:96;;7379:1;7376;7369:12;7287:96;7406:33;;7458:20;;;-1:-1:-1;;;;;;7490:30:11;;7487:50;;;7533:1;7530;7523:12;7487:50;7566:4;7554:17;;-1:-1:-1;7597:14:11;7593:27;;;7583:38;;7580:58;;;7634:1;7631;7624:12;7580:58;7123:521;;;;;:::o;8704:127::-;8765:10;8760:3;8756:20;8753:1;8746:31;8796:4;8793:1;8786:15;8820:4;8817:1;8810:15;8836:125;8901:9;;;8922:10;;;8919:36;;;8935:18;;:::i;8966:128::-;9033:9;;;9054:11;;;9051:37;;;9068:18;;:::i;9099:168::-;9172:9;;;9203;;9220:15;;;9214:22;;9200:37;9190:71;;9241:18;;:::i;9272:217::-;9312:1;9338;9328:132;;9382:10;9377:3;9373:20;9370:1;9363:31;9417:4;9414:1;9407:15;9445:4;9442:1;9435:15;9328:132;-1:-1:-1;9474:9:11;;9272:217::o;9704:446::-;9757:3;9795:5;9789:12;9822:6;9817:3;9810:19;9854:4;9849:3;9845:14;9838:21;;9893:4;9886:5;9882:16;9916:1;9926:199;9940:6;9937:1;9934:13;9926:199;;;10005:13;;-1:-1:-1;;;;;10001:39:11;9989:52;;10070:4;10061:14;;;;10098:17;;;;10037:1;9955:9;9926:199;;;-1:-1:-1;10141:3:11;;9704:446;-1:-1:-1;;;;9704:446:11:o;10155:420::-;10208:3;10246:5;10240:12;10273:6;10268:3;10261:19;10305:4;10300:3;10296:14;10289:21;;10344:4;10337:5;10333:16;10367:1;10377:173;10391:6;10388:1;10385:13;10377:173;;;10452:13;;10440:26;;10495:4;10486:14;;;;10523:17;;;;10413:1;10406:9;10377:173;;10580:1458;-1:-1:-1;;;;;11198:32:11;;;11180:51;;801:31;;11282:2;11267:18;;789:44;-1:-1:-1;;;;;801:31:11;;11337:2;11322:18;;789:44;-1:-1:-1;;;;;801:31:11;;11392:2;11377:18;;789:44;11433:6;11427:3;11416:9;11412:19;11405:35;11477:6;11471:3;11460:9;11456:19;11449:35;11521:6;11515:3;11504:9;11500:19;11493:35;11565:6;11559:3;11548:9;11544:19;11537:35;11609:6;11603:3;11592:9;11588:19;11581:35;11653:6;11647:3;11636:9;11632:19;11625:35;11697:3;11691;11680:9;11676:19;11669:32;11161:4;11724:58;11777:3;11766:9;11762:19;11753:7;11724:58;:::i;:::-;11831:9;11823:6;11819:22;11813:3;11802:9;11798:19;11791:51;11865:45;11903:6;11894:7;11865:45;:::i;:::-;11851:59;;11959:9;11951:6;11947:22;11941:3;11930:9;11926:19;11919:51;11987:45;12025:6;12016:7;11987:45;:::i;:::-;11979:53;;;10580:1458;;;;;;;;;;;;;;;;:::o;12043:301::-;12172:3;12210:6;12204:13;12256:6;12249:4;12241:6;12237:17;12232:3;12226:37;12318:1;12282:16;;12307:13;;;-1:-1:-1;12282:16:11;12043:301;-1:-1:-1;12043:301:11:o","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[{"signature":"acceptOwnership()","signatureHash4":"0x79ba5097","signatureHash32":"0x79ba5097e5519a381a52113cdcc59540d13f73fd9d26abc0453484a096cc96f2"},{"signature":"coreAddress()","signatureHash4":"0x1c0ad646","signatureHash32":"0x1c0ad6468a9d957987dd2abbbd67b664db1e1d122dc589fade27027c7e1fd326"},{"signature":"estimateSwapGas(bytes)","signatureHash4":"0x83bf2321","signatureHash32":"0x83bf2321de14ce8ff6eccc001a8380a17965867a21d101edf55eb980fd96feee"},{"signature":"fundsManagers(address)","signatureHash4":"0xabb4f0e8","signatureHash32":"0xabb4f0e83ab2c9a42254abee69dfdddb141db02bdca96b0435f923084add2310"},{"signature":"internalCallers(address)","signatureHash4":"0x683fdbf0","signatureHash32":"0x683fdbf02060b84eaa374e13d960d031dc54b2f3ca6821a3e15f2cd95a0d9f17"},{"signature":"multicall(bytes[])","signatureHash4":"0xac9650d8","signatureHash32":"0xac9650d882acfa253cba1ed543b9ff47351da99c3bd00a89625e5cdb2099009c"},{"signature":"owner()","signatureHash4":"0x8da5cb5b","signatureHash32":"0x8da5cb5b36e7f68c1d2e56001220cdbdd3ba2616072f718acfda4a06441a807d"},{"signature":"pause()","signatureHash4":"0x8456cb59","signatureHash32":"0x8456cb591a934d53f6ccc6332123a165a1f3562907bf11330d847a29ca49eb89"},{"signature":"paused()","signatureHash4":"0x5c975abb","signatureHash32":"0x5c975abbf8c4d6efa68fc896e233763eb503f2318260b7bf59b19412913788b2"},{"signature":"pendingOwner()","signatureHash4":"0xe30c3978","signatureHash32":"0xe30c3978ddd82956a01b5cb08d17f1a2d73e636aeefb7b36f896e41d4c2aab90"},{"signature":"renounceOwnership()","signatureHash4":"0x715018a6","signatureHash32":"0x715018a616b5f2044428f6fadb7deef4ce9ca76ef60ea57978964ad137bbe7ae"},{"signature":"swapWithBackendSignature(bytes)","signatureHash4":"0x46ec278a","signatureHash32":"0x46ec278a67e9079a6e8d34aeee09a30a34cb992c281d850c414fc07e7f0b8f32"},{"signature":"transfer((address,address,uint256))","signatureHash4":"0xb9b8bc50","signatureHash32":"0xb9b8bc5007ebaeba7105182c819ec712ebb7d58b0d5b7bb353b8d748c0575971"},{"signature":"transferMany((address,address,uint256)[])","signatureHash4":"0x5e1e0311","signatureHash32":"0x5e1e03111f09ae68fff108aea7a04621065f793def7e79cb3a625551087d96dd"},{"signature":"transferOwnership(address)","signatureHash4":"0xf2fde38b","signatureHash32":"0xf2fde38b092330466c661fc723d5289b90272a3e580e3187d1d7ef788506c557"},{"signature":"unpause()","signatureHash4":"0x3f4ba83a","signatureHash32":"0x3f4ba83af89dc9793996d9e56b8abe6dc88cd97c9c2bb23027806e9c1ffd54dc"},{"signature":"updateAmountIn(bytes,uint256)","signatureHash4":"0xa8e0072d","signatureHash32":"0xa8e0072dce1a9f8586fb112886c9d3a961c2d66b21231834e15d6d329ed60eb9"},{"signature":"updateCoreAddress(address)","signatureHash4":"0x364f9cf8","signatureHash32":"0x364f9cf825d91a3bca143e72c05cb674c7170fdffef44714fa1d5ce1935dedf4"},{"signature":"updateFundsManager(address,bool)","signatureHash4":"0x0358cd50","signatureHash32":"0x0358cd50b7bc0b4e397a4ed09076ebcefd5dd60558f0c21a2e1664e706a4075a"},{"signature":"updateInternalCaller(address,bool)","signatureHash4":"0x519a98e0","signatureHash32":"0x519a98e03485ac2867bce3a8a15086a89476c8335ea3b264a5cd577665565ecc"},{"signature":"updateWeth(address)","signatureHash4":"0x1b5ad801","signatureHash32":"0x1b5ad801bce9d263d0ff86d01407de531266af029a7aaa77ff7b4b39751cbdfa"},{"signature":"weth()","signatureHash4":"0x3fc8cef3","signatureHash32":"0x3fc8cef3584510d52761a06b1790c486c391517f6e5b3918a42917c24e69d082"}],"event":[{"signature":"OwnershipTransferred(address,address)","signatureHash4":"0x8be0079c","signatureHash32":"0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0"},{"signature":"OwnershipTransferStarted(address,address)","signatureHash4":"0x38d16b8c","signatureHash32":"0x38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e22700"},{"signature":"Paused(address)","signatureHash4":"0x62e78cea","signatureHash32":"0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258"},{"signature":"Swap(address,address,address,address,uint256,uint256,uint256,uint256,uint256,bytes32,address[],address[],uint256[])","signatureHash4":"0xac98876c","signatureHash32":"0xac98876c63e9e95442ed72d8ca81d9a5c922f18616dc2b8b155416310b898dd9"},{"signature":"Unpaused(address)","signatureHash4":"0x5db9ee0a","signatureHash32":"0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa"},{"signature":"UpdateFundsManager(address,address,bool)","signatureHash4":"0xdc3cb12d","signatureHash32":"0xdc3cb12d85422cbe241250c703895c83bd9eab50442bc8509b25e26be8d3c907"},{"signature":"UpdateInternalCaller(address,address,bool)","signatureHash4":"0xa71618a9","signatureHash32":"0xa71618a9ed4e81ce27edc2700d38db549c32abb5e4f32ec57f791151030fbc45"}],"error":[{"signature":"ApprovalFailed()","signatureHash4":"0x8164f842","signatureHash32":"0x8164f8420f269e65f628de89f74bfefdaed46f99c50d22c6a87ba81966095c96"},{"signature":"FailedWrap()","signatureHash4":"0xbdc844ed","signatureHash32":"0xbdc844ed51a5067257e3895134dd39786d0a5bc002f483c773217a0b69a78752"},{"signature":"InsufficientAmountOut()","signatureHash4":"0xe52970aa","signatureHash32":"0xe52970aa7a07a5a0be402e4424fec19db8cbb43b30df2e916aa8be93eb2c27ad"},{"signature":"InvalidFundManager()","signatureHash4":"0x80fddd88","signatureHash32":"0x80fddd88af3889e14bfbabe888892a44f05f173e5100bb7a45acc1bf0bc4b246"},{"signature":"InvalidNativeAmount()","signatureHash4":"0x44e8bd2c","signatureHash32":"0x44e8bd2c045de370864f4011168d4d20cb1122869813b744a39221e8e76f11ce"},{"signature":"InvalidSignature()","signatureHash4":"0x8baa579f","signatureHash32":"0x8baa579fce362245063d36f11747a89dd489c54795634fc673cc0e0db51fedc5"},{"signature":"TransferFailed()","signatureHash4":"0x90b8ec18","signatureHash32":"0x90b8ec1877afffd816d05d9b13947f3ff18ec5851c38bad15ec2b710f92391b1"},{"signature":"TransferFromFailed()","signatureHash4":"0x7939f424","signatureHash32":"0x7939f424dcbfa2fa1d156b76cc697c9670f0bbaf8cf205037134e844b4916e74"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"1","address":"0x20F6ee51340aDEed01A59B0e65cB3703f3dc860c"}