{"matchId":"6208955","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2025-03-13T18:37:31Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"287:8141:4:-:0;;;1184:337;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1286:8;:20;;-1:-1:-1;;;;;;1286:20:4;-1:-1:-1;;;;;1286:20:4;;;;;1310:101;1334:14;:21;1330:1;:25;1310:101;;;1402:4;1367:13;:32;1381:14;1396:1;1381:17;;;;;;-1:-1:-1;;;1381:17:4;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1367:32:4;;;;;;;;;;;-1:-1:-1;1367:32:4;:39;;-1:-1:-1;;1367:39:4;;;;;;;;;;1357:3;;;;:::i;:::-;;;;1310:101;;;;1419:9;1414:104;1438:15;:22;1434:1;:26;1414:104;;;1509:4;1472:14;:34;1487:15;1503:1;1487:18;;;;;;-1:-1:-1;;;1487:18:4;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1472:34:4;;;;;;;;;;;-1:-1:-1;1472:34:4;:41;;-1:-1:-1;;1472:41:4;;;;;;;;;;1462:3;;;;:::i;:::-;;;;1414:104;;;;1184:337;;;287:8141;;14:177:6;93:13;;-1:-1:-1;;;;;135:31:6;;125:42;;115:2;;181:1;178;171:12;115:2;74:117;;;:::o;196:954::-;261:5;314:3;307:4;299:6;295:17;291:27;281:2;;336:5;329;322:20;281:2;363:13;;395:4;-1:-1:-1;;;;;448:10:6;;;445:2;;;461:18;;:::i;:::-;507:2;504:1;500:10;539:2;533:9;602:2;598:7;593:2;589;585:11;581:25;573:6;569:38;657:6;645:10;642:22;637:2;625:10;622:18;619:46;616:2;;;668:18;;:::i;:::-;704:2;697:22;754:18;;;788:15;;;;-1:-1:-1;823:15:6;;;857;;;853:24;;850:33;-1:-1:-1;847:2:6;;;900:5;893;886:20;847:2;926:5;917:14;;940:180;954:2;951:1;948:9;940:180;;;1011:34;1041:3;1011:34;:::i;:::-;999:47;;1066:12;;;;972:1;965:9;;;;;1098:12;;940:180;;;-1:-1:-1;1138:6:6;271:879;-1:-1:-1;;;;;;;271:879:6:o;1155:729::-;1293:6;1301;1309;1362:2;1350:9;1341:7;1337:23;1333:32;1330:2;;;1383:6;1375;1368:22;1330:2;1411:40;1441:9;1411:40;:::i;:::-;1495:2;1480:18;;1474:25;1401:50;;-1:-1:-1;;;;;;1548:14:6;;;1545:2;;;1580:6;1572;1565:22;1545:2;1608:72;1672:7;1663:6;1652:9;1648:22;1608:72;:::i;:::-;1598:82;;1726:2;1715:9;1711:18;1705:25;1689:41;;1755:2;1745:8;1742:16;1739:2;;;1776:6;1768;1761:22;1739:2;;1804:74;1870:7;1859:8;1848:9;1844:24;1804:74;:::i;:::-;1794:84;;;1320:564;;;;;:::o;1889:236::-;1928:3;-1:-1:-1;;1949:17:6;;1946:2;;;-1:-1:-1;;;1989:33:6;;2045:4;2042:1;2035:15;2075:4;1996:3;2063:17;1946:2;-1:-1:-1;2117:1:6;2106:13;;1936:189::o;2130:127::-;2191:10;2186:3;2182:20;2179:1;2172:31;2222:4;2219:1;2212:15;2246:4;2243:1;2236:15;2162:95;287:8141:4;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa26469706673582212200f6ffdf358e4879a270e9a6969d8c6d1c37b5db041f7c92677ea51f62053052b64736f6c63430008040033","offset":9526}},"transformations":[{"type":"insert","offset":9579,"reason":"constructorArguments"}],"transformationValues":{"constructorArguments":"0x000000000000000000000000933e3922e04d47a466e60a20e486b372b64f1ea8000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000002000000000000000000000000111111125421ca6dc452d289314280a0f8842a650000000000000000000000005e18824bb0e73bb9bd78e7b2d38a3289bccdee1d0000000000000000000000000000000000000000000000000000000000000004000000000000000000000000875d6d37ec55c8cf220b9e5080717549d8aa8eca000000000000000000000000c38e4e6a15593f908255214653d3d947ca1c2338000000000000000000000000cbe9186a89db78714785765055e09dd6166e0833000000000000000000000000bf5f3f65102ae745a48bd521d10bab5bf02a9ef4"}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"287:8141:4:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7789:138;;;;;;;;;;-1:-1:-1;7789:138:4;;;;;:::i;:::-;;:::i;:::-;;3621:1707;;;;;;:::i;:::-;;:::i;415:23::-;;;;;;;;;;-1:-1:-1;415:23:4;;;;-1:-1:-1;;;;;415:23:4;;;;;;-1:-1:-1;;;;;8360:55:6;;;8342:74;;8330:2;8315:18;415:23:4;;;;;;;;7930:124;;;;;;;;;;;;;:::i;441:27::-;;;;;;;;;;-1:-1:-1;441:27:4;;;;-1:-1:-1;;;;;441:27:4;;;8057:165;;;;;;;;;;-1:-1:-1;8057:165:4;;;;;:::i;:::-;;:::i;8225:169::-;;;;;;;;;;-1:-1:-1;8225:169:4;;;;;:::i;:::-;;:::i;519:46::-;;;;;;;;;;-1:-1:-1;519:46:4;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;12016:14:6;;12009:22;11991:41;;11979:2;11964:18;519:46:4;11946:92:6;1524:351:4;;;;;;:::i;:::-;;:::i;7511:275::-;;;;;;;;;;-1:-1:-1;7511:275:4;;;;;:::i;:::-;;:::i;1879:558::-;;;;;;:::i;:::-;;:::i;7339:169::-;;;;;;;;;;-1:-1:-1;7339:169:4;;;;;:::i;:::-;;:::i;2440:1178::-;;;;;;:::i;:::-;;:::i;471:45::-;;;;;;;;;;-1:-1:-1;471:45:4;;;;;:::i;:::-;;;;;;;;;;;;;;;;7789:138;7867:8;;-1:-1:-1;;;;;7867:8:4;7853:10;:22;7845:48;;;;-1:-1:-1;;;7845:48:4;;13751:2:6;7845:48:4;;;13733:21:6;13790:2;13770:18;;;13763:30;-1:-1:-1;;;13809:18:6;;;13802:43;13862:18;;7845:48:4;;;;;;;;;7897:12;:26;;-1:-1:-1;;7897:26:4;-1:-1:-1;;;;;7897:26:4;;;;;;;;;;7789:138::o;3621:1707::-;-1:-1:-1;;;;;3910:27:4;;;;;;:13;:27;;;;;;;;3909:28;;:62;;-1:-1:-1;;;;;;3942:29:4;;;;;;:14;:29;;;;;;;;3941:30;3909:62;3905:106;;;3985:21;;-1:-1:-1;;;3985:21:4;;;;;;;;;;;3905:106;4033:11;-1:-1:-1;;;;;4022:22:4;:7;-1:-1:-1;;;;;4022:22:4;;;4014:73;;;;-1:-1:-1;;;4014:73:4;;18131:2:6;4014:73:4;;;18113:21:6;18170:2;18150:18;;;18143:30;18209:34;18189:18;;;18182:62;18280:8;18260:18;;;18253:36;18306:19;;4014:73:4;18103:228:6;4014:73:4;4114:40;;-1:-1:-1;;;4114:40:4;;4148:4;4114:40;;;8342:74:6;4091:20:4;;-1:-1:-1;;;;;4114:25:4;;;;;8315:18:6;;4114:40:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4091:63;;4158:44;4170:7;4179:8;4189:12;4158:11;:44::i;:::-;4207:20;-1:-1:-1;;;;;4235:25:4;;;4231:152;;4282:44;;-1:-1:-1;;;4282:44:4;;4320:4;4282:44;;;8342:74:6;-1:-1:-1;;;;;4282:29:4;;;;;8315:18:6;;4282:44:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4267:59;;4231:152;;;-1:-1:-1;4357:21:4;4231:152;4387:51;4406:7;4415:12;4429:8;4387:18;:51::i;:::-;4443:12;4461;-1:-1:-1;;;;;4461:17:4;4486:1;4489:8;;4461:37;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4442:56;;;4510:7;4502:45;;;;-1:-1:-1;;;4502:45:4;;17777:2:6;4502:45:4;;;17759:21:6;17816:2;17796:18;;;17789:30;17855:27;17835:18;;;17828:55;17900:18;;4502:45:4;17749:175:6;4502:45:4;-1:-1:-1;;;;;4556:25:4;;;4552:182;;4603:44;;-1:-1:-1;;;4603:44:4;;4641:4;4603:44;;;8342:74:6;4650:12:4;;-1:-1:-1;;;;;4603:29:4;;;;;8315:18:6;;4603:44:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:59;;;;:::i;:::-;4588:74;;4552:182;;;4693:36;4717:12;4693:21;:36;:::i;:::-;4678:51;;4552:182;4761:15;4745:12;:31;;4737:69;;;;-1:-1:-1;;;4737:69:4;;12633:2:6;4737:69:4;;;12615:21:6;12672:2;12652:18;;;12645:30;12711:27;12691:18;;;12684:55;12756:18;;4737:69:4;12605:175:6;4737:69:4;4825:9;-1:-1:-1;;;;;4842:25:4;;4838:136;;4874:19;4881:12;4874:19;;:::i;:::-;;;4838:136;;;4909:60;4928:11;4941:13;4956:12;4909:18;:60::i;:::-;-1:-1:-1;;;;;4992:18:4;;;;5018:3;;5023:25;;;:84;;5063:44;5083:9;;5094:12;5063:19;:44::i;:::-;5023:84;;;5051:9;;5023:84;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;5023:84:4;4992:116;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4978:130;;;;;5120:7;5112:46;;;;-1:-1:-1;;;5112:46:4;;15132:2:6;5112:46:4;;;15114:21:6;15171:2;15151:18;;;15144:30;15210:28;15190:18;;;15183:56;15256:18;;5112:46:4;15104:176:6;5112:46:4;5163:44;5185:7;5194:12;5163:21;:44::i;:::-;5217:107;5239:7;5248:8;5258:12;5272:11;5285:12;5299:13;5314:9;;5217:107;;;;;;;;;;;;;:::i;:::-;;;;;;;;3621:1707;;;;;;;;;;;;;;;:::o;7930:124::-;7988:12;;-1:-1:-1;;;;;7988:12:4;7974:10;:26;7966:57;;;;-1:-1:-1;;;7966:57:4;;14093:2:6;7966:57:4;;;14075:21:6;14132:2;14112:18;;;14105:30;14171:20;14151:18;;;14144:48;14209:18;;7966:57:4;14065:168:6;7966:57:4;8038:12;;;8027:23;;-1:-1:-1;;8027:23:4;-1:-1:-1;;;;;8038:12:4;;;8027:23;;;;;;7930:124::o;8057:165::-;8151:8;;-1:-1:-1;;;;;8151:8:4;8137:10;:22;8129:48;;;;-1:-1:-1;;;8129:48:4;;13751:2:6;8129:48:4;;;13733:21:6;13790:2;13770:18;;;13763:30;-1:-1:-1;;;13809:18:6;;;13802:43;13862:18;;8129:48:4;13723:163:6;8129:48:4;-1:-1:-1;;;;;8181:27:4;;;;;;;;:13;:27;;;;;:37;;-1:-1:-1;;8181:37:4;;;;;;;;;;8057:165::o;8225:169::-;8321:8;;-1:-1:-1;;;;;8321:8:4;8307:10;:22;8299:48;;;;-1:-1:-1;;;8299:48:4;;13751:2:6;8299:48:4;;;13733:21:6;13790:2;13770:18;;;13763:30;-1:-1:-1;;;13809:18:6;;;13802:43;13862:18;;8299:48:4;13723:163:6;8299:48:4;-1:-1:-1;;;;;8351:29:4;;;;;;;;:14;:29;;;;;:39;;-1:-1:-1;;8351:39:4;;;;;;;;;;8225:169::o;1524:351::-;-1:-1:-1;;;;;1629:29:4;;;;;;:14;:29;;;;;;;;1624:74;;1672:21;;-1:-1:-1;;;1672:21:4;;;;;;;;;;;1624:74;1702:12;1720:13;-1:-1:-1;;;;;1720:18:4;1746:9;1757:12;;1720:50;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1701:69;;;1782:7;1774:46;;;;-1:-1:-1;;;1774:46:4;;15132:2:6;1774:46:4;;;15114:21:6;15171:2;15151:18;;;15144:30;15210:28;15190:18;;;15183:56;15256:18;;1774:46:4;15104:176:6;1774:46:4;1830:41;1843:13;1858:12;;1830:41;;;;;;;;:::i;:::-;;;;;;;;1524:351;;;;:::o;7511:275::-;7599:8;;-1:-1:-1;;;;;7599:8:4;7585:10;:22;7577:48;;;;-1:-1:-1;;;7577:48:4;;13751:2:6;7577:48:4;;;13733:21:6;13790:2;13770:18;;;13763:30;-1:-1:-1;;;13809:18:6;;;13802:43;13862:18;;7577:48:4;13723:163:6;7577:48:4;-1:-1:-1;;;;;7637:16:4;;7629:57;;;;-1:-1:-1;;;7629:57:4;;12987:2:6;7629:57:4;;;12969:21:6;13026:2;13006:18;;;12999:30;13065;13045:18;;;13038:58;13113:18;;7629:57:4;12959:178:6;7629:57:4;7691:12;7717:2;-1:-1:-1;;;;;7709:16:4;7733:6;7709:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7690:54;;;7756:7;7748:34;;;;-1:-1:-1;;;7748:34:4;;14440:2:6;7748:34:4;;;14422:21:6;14479:2;14459:18;;;14452:30;14518:16;14498:18;;;14491:44;14552:18;;7748:34:4;14412:164:6;7748:34:4;7511:275;;;:::o;1879:558::-;-1:-1:-1;;;;;2064:29:4;;;;;;:14;:29;;;;;;;;2059:74;;2107:21;;-1:-1:-1;;;2107:21:4;;;;;;;;;;;2059:74;2137:44;2149:7;2158:8;2168:12;2137:11;:44::i;:::-;2186:52;2205:7;2214:13;2229:8;2186:18;:52::i;:::-;2243:12;2261:13;-1:-1:-1;;;;;2261:18:4;2287:9;2298:12;;2261:50;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2242:69;;;2323:7;2315:46;;;;-1:-1:-1;;;2315:46:4;;15132:2:6;2315:46:4;;;15114:21:6;15171:2;15151:18;;;15144:30;15210:28;15190:18;;;15183:56;15256:18;;2315:46:4;15104:176:6;2315:46:4;2371:62;2386:7;2395:8;2405:13;2420:12;;2371:62;;;;;;;;;;:::i;:::-;;;;;;;;1879:558;;;;;;;:::o;7339:169::-;7436:8;;-1:-1:-1;;;;;7436:8:4;7422:10;:22;7414:48;;;;-1:-1:-1;;;7414:48:4;;13751:2:6;7414:48:4;;;13733:21:6;13790:2;13770:18;;;13763:30;-1:-1:-1;;;13809:18:6;;;13802:43;13862:18;;7414:48:4;13723:163:6;7414:48:4;7466:38;-1:-1:-1;;;;;7466:26:4;;7493:2;7497:6;7466:26;:38::i;2440:1178::-;-1:-1:-1;;;;;2670:27:4;;;;;;:13;:27;;;;;;;;2669:28;;:62;;-1:-1:-1;;;;;;2702:29:4;;;;;;:14;:29;;;;;;;;2701:30;2669:62;2665:106;;;2745:21;;-1:-1:-1;;;2745:21:4;;;;;;;;;;;2665:106;-1:-1:-1;;;;;2782:25:4;;2774:72;;;;-1:-1:-1;;;2774:72:4;;15487:2:6;2774:72:4;;;15469:21:6;15526:2;15506:18;;;15499:30;15565:34;15545:18;;;15538:62;-1:-1:-1;;;15616:18:6;;;15609:32;15658:19;;2774:72:4;15459:224:6;2774:72:4;2872:8;2859:9;:21;;2851:55;;;;-1:-1:-1;;;2851:55:4;;17004:2:6;2851:55:4;;;16986:21:6;17043:2;17023:18;;;17016:30;17082:23;17062:18;;;17055:51;17123:18;;2851:55:4;16976:171:6;2851:55:4;2933:44;;-1:-1:-1;;;2933:44:4;;2971:4;2933:44;;;8342:74:6;2910:20:4;;-1:-1:-1;;;;;2933:29:4;;;;;8315:18:6;;2933:44:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2910:67;;2983:12;3001;-1:-1:-1;;;;;3001:17:4;3026:8;3036;;3001:44;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2982:63;;;3057:7;3049:36;;;;-1:-1:-1;;;3049:36:4;;16248:2:6;3049:36:4;;;16230:21:6;16287:2;16267:18;;;16260:30;16326:18;16306;;;16299:46;16362:18;;3049:36:4;16220:166:6;3049:36:4;3105:44;;-1:-1:-1;;;3105:44:4;;3143:4;3105:44;;;8342:74:6;3152:12:4;;-1:-1:-1;;;;;3105:29:4;;;;;8315:18:6;;3105:44:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:59;;;;:::i;:::-;3090:74;;3192:15;3176:12;:31;;3168:69;;;;-1:-1:-1;;;3168:69:4;;12633:2:6;3168:69:4;;;12615:21:6;12672:2;12652:18;;;12645:30;12711:27;12691:18;;;12684:55;12756:18;;3168:69:4;12605:175:6;3168:69:4;3242:60;3261:11;3274:13;3289:12;3242:18;:60::i;:::-;3307:25;3335:44;3355:9;;3366:12;3335:19;:44::i;:::-;3307:72;-1:-1:-1;;;;;;3397:18:4;;3423:20;3435:8;3423:9;:20;:::i;:::-;3445:12;3397:61;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3383:75;;;;;3470:7;3462:46;;;;-1:-1:-1;;;3462:46:4;;15132:2:6;3462:46:4;;;15114:21:6;15171:2;15151:18;;;15144:30;15210:28;15190:18;;;15183:56;15256:18;;3462:46:4;15104:176:6;3462:46:4;3518:96;3538:8;3548:12;3562:11;3575:12;3589:13;3604:9;;3518:96;;;;;;;;;;;;:::i;:::-;;;;;;;;2440:1178;;;;;;;;;;;;:::o;6736:347::-;6870:52;;-1:-1:-1;;;6870:52:4;;6896:10;6870:52;;;8662:34:6;6916:4:4;8712:18:6;;;8705:43;6850:17:4;;-1:-1:-1;;;;;6870:25:4;;;;;8574:18:6;;6870:52:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;6850:72;;6942:8;6930:9;:20;6926:81;;;6957:45;6968:7;6977:10;6989:12;6957:10;:45::i;:::-;7010:69;-1:-1:-1;;;;;7010:32:4;;7043:10;7063:4;7070:8;7010:32;:69::i;:::-;6736:347;;;;:::o;6131:323::-;6287:39;;-1:-1:-1;;;6287:39:4;;6311:4;6287:39;;;8662:34:6;-1:-1:-1;;;;;8732:15:6;;;8712:18;;;8705:43;6246:9:4;;6224:12;;6287:15;;;;;8574:18:6;;6287:39:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;6260:66;;6354:6;6335:16;:25;6331:120;;;6367:29;-1:-1:-1;;;;;6367:17:4;;6385:7;6394:1;6367:17;:29::i;:::-;6401:45;-1:-1:-1;;;;;6401:17:4;;6419:7;-1:-1:-1;;6401:17:4;:45::i;:::-;6131:323;;;;;:::o;5331:797::-;5430:12;5476:2;5456:22;;;5448:55;;;;-1:-1:-1;;;5448:55:4;;14783:2:6;5448:55:4;;;14765:21:6;14822:2;14802:18;;;14795:30;14861:22;14841:18;;;14834:50;14901:18;;5448:55:4;14755:170:6;5448:55:4;5507:25;5545:9;5535:27;;;;;;-1:-1:-1;;;5535:27:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;5535:27:4;;5507:55;;5617:6;5612:70;5633:2;5629:1;:6;5612:70;;;5665:9;;5675:1;5665:12;;;;;-1:-1:-1;;;5665:12:4;;;;;;;;;;;;;;;;;5647;5660:1;5647:15;;;;;;-1:-1:-1;;;5647:15:4;;;;;;;;;;;;:30;-1:-1:-1;;;;;5647:30:4;;;;;;;;-1:-1:-1;5637:3:4;;;;:::i;:::-;;;;5612:70;;;;5811:26;5851:12;5840:24;;;;;;18482:25:6;;18470:2;18455:18;;18437:76;5840:24:4;;;;;;;;;;;;;5811:53;;5873:6;5868:79;5889:2;5885:1;:6;5868:79;;;5926:13;5940:1;5926:16;;;;;;-1:-1:-1;;;5926:16:4;;;;;;;;;;;;;;;5903:12;5916:6;:1;5920:2;5916:6;:::i;:::-;5903:20;;;;;;-1:-1:-1;;;5903:20:4;;;;;;;;;;;;:39;-1:-1:-1;;;;;5903:39:4;;;;;;;;-1:-1:-1;5893:3:4;;;;:::i;:::-;;;;5868:79;;;-1:-1:-1;6030:2:4;6016:85;6034:20;;;6016:85;;;6084:9;;6094:1;6084:12;;;;;-1:-1:-1;;;6084:12:4;;;;;;;;;;;;;;;;;6066;6079:1;6066:15;;;;;;-1:-1:-1;;;6066:15:4;;;;;;;;;;;;:30;-1:-1:-1;;;;;6066:30:4;;;;;;;;-1:-1:-1;6056:3:4;;;;:::i;:::-;;;;6016:85;;;-1:-1:-1;6112:12:4;;5331:797;-1:-1:-1;;;;;5331:797:4:o;7086:250::-;7187:38;;-1:-1:-1;;;7187:38:4;;7219:4;7187:38;;;8342:74:6;7167:17:4;;-1:-1:-1;;;;;7187:23:4;;;;;8315:18:6;;7187:38:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;7167:58;;7245:12;7233:9;:24;7229:104;;;7264:64;7291:10;7303:24;7315:12;7303:9;:24;:::i;:::-;-1:-1:-1;;;;;7264:26:4;;;:64;941:175:2;1050:58;;-1:-1:-1;;;;;10421:55:6;;1050:58:2;;;10403:74:6;10493:18;;;10486:34;;;1023:86:2;;1043:5;;-1:-1:-1;;;1073:23:2;10376:18:6;;1050:58:2;;;;-1:-1:-1;;1050:58:2;;;;;;;;;;;;;;;;;;;;;;;;;;;1023:19;:86::i;6457:276:4:-;-1:-1:-1;;;;;6565:26:4;;;6596:5;6614:4;6624:18;;6647:21;;;;6673:14;;;;;;;;:::i;:::-;6565:164;;;;;;;;;;-1:-1:-1;;;;;9552:15:6;;;6565:164:4;;;9534:34:6;9604:15;;;;9584:18;;;9577:43;9636:18;;;9629:34;;;;9679:18;;;9672:34;9755:4;9743:17;9722:19;;;9715:46;6692:14:4;;;;9777:19:6;;;9770:35;6711:14:4;;;;9821:19:6;;;9814:35;9445:19;;6565:164:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6457:276;;;:::o;1355:203:2:-;1482:68;;-1:-1:-1;;;;;9040:15:6;;;1482:68:2;;;9022:34:6;9092:15;;9072:18;;;9065:43;9124:18;;;9117:34;;;1455:96:2;;1475:5;;-1:-1:-1;;;1505:27:2;8934:18:6;;1482:68:2;8916:241:6;1818:573:2;2143:10;;;2142:62;;-1:-1:-1;2159:39:2;;-1:-1:-1;;;2159:39:2;;2183:4;2159:39;;;8662:34:6;-1:-1:-1;;;;;8732:15:6;;;8712:18;;;8705:43;2159:15:2;;;;;8574:18:6;;2159:39:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;2142:62;2121:163;;;;-1:-1:-1;;;2121:163:2;;17354:2:6;2121:163:2;;;17336:21:6;17393:2;17373:18;;;17366:30;17432:34;17412:18;;;17405:62;17503:24;17483:18;;;17476:52;17545:19;;2121:163:2;17326:244:6;2121:163:2;2321:62;;-1:-1:-1;;;;;10421:55:6;;2321:62:2;;;10403:74:6;10493:18;;;10486:34;;;2294:90:2;;2314:5;;-1:-1:-1;;;2344:22:2;10376:18:6;;2321:62:2;10358:168:6;5196:642:2;5615:23;5641:69;5669:4;5641:69;;;;;;;;;;;;;;;;;5649:5;-1:-1:-1;;;;;5641:27:2;;;:69;;;;;:::i;:::-;5615:95;;5728:10;:17;5749:1;5728:22;:56;;;;5765:10;5754:30;;;;;;;;;;;;:::i;:::-;5720:111;;;;-1:-1:-1;;;5720:111:2;;16593:2:6;5720:111:2;;;16575:21:6;16632:2;16612:18;;;16605:30;16671:34;16651:18;;;16644:62;16742:12;16722:18;;;16715:40;16772:19;;5720:111:2;16565:232:6;4108:223:3;4241:12;4272:52;4294:6;4302:4;4308:1;4311:12;4272:21;:52::i;:::-;4265:59;4108:223;-1:-1:-1;;;;4108:223:3:o;5165:446::-;5330:12;5387:5;5362:21;:30;;5354:81;;;;-1:-1:-1;;;5354:81:3;;13344:2:6;5354:81:3;;;13326:21:6;13383:2;13363:18;;;13356:30;13422:34;13402:18;;;13395:62;13493:8;13473:18;;;13466:36;13519:19;;5354:81:3;13316:228:6;5354:81:3;5446:12;5460:23;5487:6;-1:-1:-1;;;;;5487:11:3;5506:5;5513:4;5487:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5445:73;;;;5535:69;5562:6;5570:7;5579:10;5591:12;5535:26;:69::i;:::-;5528:76;5165:446;-1:-1:-1;;;;;;;5165:446:3:o;7671:628::-;7851:12;7879:7;7875:418;;;7906:17;;7902:286;;-1:-1:-1;;;;;1702:19:3;;;8113:60;;;;-1:-1:-1;;;8113:60:3;;15890:2:6;8113:60:3;;;15872:21:6;15929:2;15909:18;;;15902:30;15968:31;15948:18;;;15941:59;16017:18;;8113:60:3;15862:179:6;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;9161:133;9331:12;9324:20;;-1:-1:-1;;;9324:20:3;;;;;;;;:::i;14:134:6:-;82:20;;111:31;82:20;111:31;:::i;:::-;63:85;;;:::o;153:375::-;204:8;214:6;268:3;261:4;253:6;249:17;245:27;235:2;;293:8;283;276:26;235:2;-1:-1:-1;323:20:6;;366:18;355:30;;352:2;;;405:8;395;388:26;352:2;449:4;441:6;437:17;425:29;;501:3;494:4;485:6;477;473:19;469:30;466:39;463:2;;;518:1;515;508:12;463:2;225:303;;;;;:::o;533:169::-;598:5;643:3;634:6;629:3;625:16;621:26;618:2;;;664:5;657;650:20;618:2;-1:-1:-1;690:6:6;608:94;-1:-1:-1;608:94:6:o;707:257::-;766:6;819:2;807:9;798:7;794:23;790:32;787:2;;;840:6;832;825:22;787:2;884:9;871:23;903:31;928:5;903:31;:::i;:::-;953:5;777:187;-1:-1:-1;;;777:187:6:o;969:392::-;1034:6;1042;1095:2;1083:9;1074:7;1070:23;1066:32;1063:2;;;1116:6;1108;1101:22;1063:2;1160:9;1147:23;1179:31;1204:5;1179:31;:::i;:::-;1229:5;-1:-1:-1;1286:2:6;1271:18;;1258:32;1299:30;1258:32;1299:30;:::i;:::-;1348:7;1338:17;;;1053:308;;;;;:::o;1366:564::-;1445:6;1453;1461;1514:2;1502:9;1493:7;1489:23;1485:32;1482:2;;;1535:6;1527;1520:22;1482:2;1579:9;1566:23;1598:31;1623:5;1598:31;:::i;:::-;1648:5;-1:-1:-1;1704:2:6;1689:18;;1676:32;1731:18;1720:30;;1717:2;;;1768:6;1760;1753:22;1717:2;1812:58;1862:7;1853:6;1842:9;1838:22;1812:58;:::i;:::-;1472:458;;1889:8;;-1:-1:-1;1786:84:6;;-1:-1:-1;;;;1472:458:6:o;1935:466::-;2012:6;2020;2028;2081:2;2069:9;2060:7;2056:23;2052:32;2049:2;;;2102:6;2094;2087:22;2049:2;2146:9;2133:23;2165:31;2190:5;2165:31;:::i;:::-;2215:5;-1:-1:-1;2267:2:6;2252:18;;2239:32;;-1:-1:-1;2323:2:6;2308:18;;2295:32;2336:33;2295:32;2336:33;:::i;:::-;2388:7;2378:17;;;2039:362;;;;;:::o;2406:911::-;2543:6;2551;2559;2567;2575;2583;2636:3;2624:9;2615:7;2611:23;2607:33;2604:2;;;2658:6;2650;2643:22;2604:2;2702:9;2689:23;2721:31;2746:5;2721:31;:::i;:::-;2771:5;-1:-1:-1;2823:2:6;2808:18;;2795:32;;-1:-1:-1;2846:68:6;2906:7;2901:2;2886:18;;2846:68;:::i;:::-;2836:78;;2966:3;2955:9;2951:19;2938:33;2980;3005:7;2980:33;:::i;:::-;3032:7;-1:-1:-1;3090:3:6;3075:19;;3062:33;3118:18;3107:30;;3104:2;;;3155:6;3147;3140:22;3104:2;3199:58;3249:7;3240:6;3229:9;3225:22;3199:58;:::i;:::-;2594:723;;;;-1:-1:-1;2594:723:6;;-1:-1:-1;2594:723:6;;3276:8;;2594:723;-1:-1:-1;;;2594:723:6:o;3322:1429::-;3506:6;3514;3522;3530;3538;3546;3554;3562;3570;3578;3586:7;3640:3;3628:9;3619:7;3615:23;3611:33;3608:2;;;3662:6;3654;3647:22;3608:2;3680:49;3718:9;3705:23;3680:49;:::i;:::-;3761:9;3748:23;3738:33;;3818:2;3807:9;3803:18;3790:32;3780:42;;3841:68;3901:7;3896:2;3885:9;3881:18;3841:68;:::i;:::-;3831:78;;3918:59;3971:3;3960:9;3956:19;3943:33;3918:59;:::i;:::-;4024:3;4013:9;4009:19;3996:33;3986:43;;4048:18;4116:2;4109:3;4098:9;4094:19;4081:33;4078:41;4075:2;;;4137:6;4129;4122:22;4075:2;4181:85;4258:7;4250:3;4239:9;4235:19;4222:33;4211:9;4207:49;4181:85;:::i;:::-;4285:8;;-1:-1:-1;4312:8:6;-1:-1:-1;4339:39:6;4373:3;4358:19;;4339:39;:::i;:::-;4329:49;;4425:3;4414:9;4410:19;4397:33;4387:43;;4449:39;4483:3;4472:9;4468:19;4449:39;:::i;:::-;4439:49;;4538:2;4531:3;4520:9;4516:19;4503:33;4500:41;4497:2;;;4559:6;4551;4544:22;4497:2;;4604:85;4681:7;4673:3;4662:9;4658:19;4645:33;4634:9;4630:49;4604:85;:::i;:::-;4708:8;4698:18;;4736:9;4725:20;;;;3598:1153;;;;;;;;;;;;;;:::o;4756:255::-;4823:6;4876:2;4864:9;4855:7;4851:23;4847:32;4844:2;;;4897:6;4889;4882:22;4844:2;4934:9;4928:16;4953:28;4975:5;4953:28;:::i;5016:194::-;5086:6;5139:2;5127:9;5118:7;5114:23;5110:32;5107:2;;;5160:6;5152;5145:22;5107:2;-1:-1:-1;5188:16:6;;5097:113;-1:-1:-1;5097:113:6:o;5215:333::-;5291:6;5299;5352:2;5340:9;5331:7;5327:23;5323:32;5320:2;;;5373:6;5365;5358:22;5320:2;5414:9;5401:23;5391:33;;5474:2;5463:9;5459:18;5446:32;5487:31;5512:5;5487:31;:::i;5553:1304::-;5688:6;5696;5704;5712;5720;5728;5736;5744;5752;5805:3;5793:9;5784:7;5780:23;5776:33;5773:2;;;5827:6;5819;5812:22;5773:2;5868:9;5855:23;5845:33;;5928:2;5917:9;5913:18;5900:32;5941:31;5966:5;5941:31;:::i;:::-;5991:5;-1:-1:-1;6047:2:6;6032:18;;6019:32;6070:18;6100:14;;;6097:2;;;6132:6;6124;6117:22;6097:2;6176:58;6226:7;6217:6;6206:9;6202:22;6176:58;:::i;:::-;6253:8;;-1:-1:-1;6150:84:6;-1:-1:-1;6340:2:6;6325:18;;6312:32;;-1:-1:-1;6353:33:6;6312:32;6353:33;:::i;:::-;6405:7;;-1:-1:-1;6459:3:6;6444:19;;6431:33;;-1:-1:-1;6516:3:6;6501:19;;6488:33;;6530;6488;6530;:::i;:::-;6582:7;;-1:-1:-1;6642:3:6;6627:19;;6614:33;;6659:16;;;6656:2;;;6693:6;6685;6678:22;6656:2;;6737:60;6789:7;6778:8;6767:9;6763:24;6737:60;:::i;:::-;6711:86;;6816:8;6806:18;;;6843:8;6833:18;;;5763:1094;;;;;;;;;;;:::o;6862:289::-;6919:6;6972:2;6960:9;6951:7;6947:23;6943:32;6940:2;;;6993:6;6985;6978:22;6940:2;7037:9;7024:23;7087:4;7080:5;7076:16;7069:5;7066:27;7056:2;;7112:6;7104;7097:22;7156:268;7244:6;7239:3;7232:19;7296:6;7289:5;7282:4;7277:3;7273:14;7260:43;-1:-1:-1;7214:3:6;7323:16;;;7341:4;7319:27;;;7312:40;;;;7406:2;7385:15;;;-1:-1:-1;;7381:29:6;7372:39;;;7368:50;;7222:202::o;7429:273::-;7612:6;7604;7599:3;7586:33;7568:3;7638:16;;7663:15;;;7638:16;7576:126;-1:-1:-1;7576:126:6:o;7707:274::-;7836:3;7874:6;7868:13;7890:53;7936:6;7931:3;7924:4;7916:6;7912:17;7890:53;:::i;:::-;7959:16;;;;;7844:137;-1:-1:-1;;7844:137:6:o;9860:364::-;-1:-1:-1;;;;;10049:6:6;10045:55;10034:9;10027:74;10137:2;10132;10121:9;10117:18;10110:30;10008:4;10157:61;10214:2;10203:9;10199:18;10191:6;10183;10157:61;:::i;:::-;10149:69;10017:207;-1:-1:-1;;;;;10017:207:6:o;10531:772::-;10819:4;-1:-1:-1;;;;;10929:2:6;10921:6;10917:15;10906:9;10899:34;10969:6;10964:2;10953:9;10949:18;10942:34;11024:2;11016:6;11012:15;11007:2;10996:9;10992:18;10985:43;11076:2;11068:6;11064:15;11059:2;11048:9;11044:18;11037:43;11117:6;11111:3;11100:9;11096:19;11089:35;11173:2;11165:6;11161:15;11155:3;11144:9;11140:19;11133:44;;11214:3;11208;11197:9;11193:19;11186:32;11235:62;11292:3;11281:9;11277:19;11269:6;11261;11235:62;:::i;:::-;11227:70;10828:475;-1:-1:-1;;;;;;;;;;10828:475:6:o;11308:538::-;11512:4;-1:-1:-1;;;;;11622:2:6;11614:6;11610:15;11599:9;11592:34;11662:6;11657:2;11646:9;11642:18;11635:34;11717:2;11709:6;11705:15;11700:2;11689:9;11685:18;11678:43;;11757:3;11752:2;11741:9;11737:18;11730:31;11778:62;11835:3;11824:9;11820:19;11812:6;11804;11778:62;:::i;12043:383::-;12192:2;12181:9;12174:21;12155:4;12224:6;12218:13;12267:6;12262:2;12251:9;12247:18;12240:34;12283:66;12342:6;12337:2;12326:9;12322:18;12317:2;12309:6;12305:15;12283:66;:::i;:::-;12410:2;12389:15;-1:-1:-1;;12385:29:6;12370:45;;;;12417:2;12366:54;;12164:262;-1:-1:-1;;12164:262:6:o;18518:691::-;18815:6;18804:9;18797:25;18778:4;-1:-1:-1;;;;;18931:2:6;18923:6;18919:15;18914:2;18903:9;18899:18;18892:43;18983:2;18975:6;18971:15;18966:2;18955:9;18951:18;18944:43;19023:6;19018:2;19007:9;19003:18;18996:34;19079:2;19071:6;19067:15;19061:3;19050:9;19046:19;19039:44;;19120:3;19114;19103:9;19099:19;19092:32;19141:62;19198:3;19187:9;19183:19;19175:6;19167;19141:62;:::i;:::-;19133:70;18787:422;-1:-1:-1;;;;;;;;;18787:422:6:o;19214:128::-;19254:3;19285:1;19281:6;19278:1;19275:13;19272:2;;;19291:18;;:::i;:::-;-1:-1:-1;19327:9:6;;19262:80::o;19347:125::-;19387:4;19415:1;19412;19409:8;19406:2;;;19420:18;;:::i;:::-;-1:-1:-1;19457:9:6;;19396:76::o;19477:258::-;19549:1;19559:113;19573:6;19570:1;19567:13;19559:113;;;19649:11;;;19643:18;19630:11;;;19623:39;19595:2;19588:10;19559:113;;;19690:6;19687:1;19684:13;19681:2;;;-1:-1:-1;;19725:1:6;19707:16;;19700:27;19530:205::o;19740:135::-;19779:3;-1:-1:-1;;19800:17:6;;19797:2;;;19820:18;;:::i;:::-;-1:-1:-1;19867:1:6;19856:13;;19787:88::o;19880:127::-;19941:10;19936:3;19932:20;19929:1;19922:31;19972:4;19969:1;19962:15;19996:4;19993:1;19986:15;20012:154;-1:-1:-1;;;;;20091:5:6;20087:54;20080:5;20077:65;20067:2;;20156:1;20153;20146:12;20067:2;20057:109;:::o;20171:118::-;20257:5;20250:13;20243:21;20236:5;20233:32;20223:2;;20279:1;20276;20269:12","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa26469706673582212200f6ffdf358e4879a270e9a6969d8c6d1c37b5db041f7c92677ea51f62053052b64736f6c63430008040033","offset":8787}},"immutableReferences":{},"transformations":[],"transformationValues":{}},"deployment":{"transactionHash":"0x328d3000639b0af0b1b9be31bab01a56e1df392e444145cd1bdaeefc89c8809e","blockNumber":"21938747","transactionIndex":"35","deployer":"0xd365658D28fd15Be7a778Cb5ad76473Aef01A770"},"sources":{"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/IERC20Permit.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n */\ninterface IERC20Permit {\n    /**\n     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\n     * given ``owner``'s signed approval.\n     *\n     * IMPORTANT: The same issues {IERC20-approve} has related to transaction\n     * ordering also apply here.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `deadline` must be a timestamp in the future.\n     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\n     * over the EIP712-formatted function arguments.\n     * - the signature must use ``owner``'s current nonce (see {nonces}).\n     *\n     * For more information on the signature format, see the\n     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\n     * section].\n     */\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external;\n\n    /**\n     * @dev Returns the current nonce for `owner`. This value must be\n     * included whenever a signature is generated for {permit}.\n     *\n     * Every successful call to {permit} increases ``owner``'s nonce by one. This\n     * prevents a signature from being used multiple times.\n     */\n    function nonces(address owner) external view returns (uint256);\n\n    /**\n     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n"},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the amount of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the amount of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves `amount` tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Moves `amount` tokens from `from` to `to` using the\n     * allowance mechanism. `amount` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 amount) external returns (bool);\n}\n"},"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\nimport \"../extensions/IERC20Permit.sol\";\nimport \"../../../utils/Address.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n    using Address for address;\n\n    /**\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     */\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\n        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\n    }\n\n    /**\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\n     */\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\n        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\n    }\n\n    /**\n     * @dev Deprecated. This function has issues similar to the ones found in\n     * {IERC20-approve}, and its usage is discouraged.\n     *\n     * Whenever possible, use {safeIncreaseAllowance} and\n     * {safeDecreaseAllowance} instead.\n     */\n    function safeApprove(IERC20 token, address spender, uint256 value) internal {\n        // safeApprove should only be called when setting an initial allowance,\n        // or when resetting it to zero. To increase and decrease it, use\n        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\n        require(\n            (value == 0) || (token.allowance(address(this), spender) == 0),\n            \"SafeERC20: approve from non-zero to non-zero allowance\"\n        );\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\n    }\n\n    /**\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     */\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 oldAllowance = token.allowance(address(this), spender);\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));\n    }\n\n    /**\n     * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     */\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        unchecked {\n            uint256 oldAllowance = token.allowance(address(this), spender);\n            require(oldAllowance >= value, \"SafeERC20: decreased allowance below zero\");\n            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));\n        }\n    }\n\n    /**\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\n     * to be set to zero before setting it to a non-zero value, such as USDT.\n     */\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\n        bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);\n\n        if (!_callOptionalReturnBool(token, approvalCall)) {\n            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));\n            _callOptionalReturn(token, approvalCall);\n        }\n    }\n\n    /**\n     * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.\n     * Revert on invalid signature.\n     */\n    function safePermit(\n        IERC20Permit token,\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal {\n        uint256 nonceBefore = token.nonces(owner);\n        token.permit(owner, spender, value, deadline, v, r, s);\n        uint256 nonceAfter = token.nonces(owner);\n        require(nonceAfter == nonceBefore + 1, \"SafeERC20: permit did not succeed\");\n    }\n\n    /**\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\n     * @param token The token targeted by the call.\n     * @param data The call data (encoded using abi.encode or one of its variants).\n     */\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\n        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\n        // the target address contains contract code and also asserts for success in the low-level call.\n\n        bytes memory returndata = address(token).functionCall(data, \"SafeERC20: low-level call failed\");\n        require(returndata.length == 0 || abi.decode(returndata, (bool)), \"SafeERC20: ERC20 operation did not succeed\");\n    }\n\n    /**\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\n     * @param token The token targeted by the call.\n     * @param data The call data (encoded using abi.encode or one of its variants).\n     *\n     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.\n     */\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\n        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false\n        // and not revert is the subcall reverts.\n\n        (bool success, bytes memory returndata) = address(token).call(data);\n        return\n            success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));\n    }\n}\n"},"@openzeppelin/contracts/utils/Address.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.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"},"src/libs/BytesLib.sol":{"content":"// SPDX-License-Identifier: Unlicense\n/*\n * @title Solidity Bytes Arrays Utils\n * @author Gonçalo Sá <goncalo.sa@consensys.net>\n *\n * @dev Bytes tightly packed arrays utility library for ethereum contracts written in Solidity.\n *      The library lets you concatenate, slice and type cast bytes arrays both in memory and storage.\n */\npragma solidity >=0.8.0 <0.9.0;\n\n\nlibrary BytesLib {\n    function concat(\n        bytes memory _preBytes,\n        bytes memory _postBytes\n    )\n        internal\n        pure\n        returns (bytes memory)\n    {\n        bytes memory tempBytes;\n\n        assembly {\n            // Get a location of some free memory and store it in tempBytes as\n            // Solidity does for memory variables.\n            tempBytes := mload(0x40)\n\n            // Store the length of the first bytes array at the beginning of\n            // the memory for tempBytes.\n            let length := mload(_preBytes)\n            mstore(tempBytes, length)\n\n            // Maintain a memory counter for the current write location in the\n            // temp bytes array by adding the 32 bytes for the array length to\n            // the starting location.\n            let mc := add(tempBytes, 0x20)\n            // Stop copying when the memory counter reaches the length of the\n            // first bytes array.\n            let end := add(mc, length)\n\n            for {\n                // Initialize a copy counter to the start of the _preBytes data,\n                // 32 bytes into its memory.\n                let cc := add(_preBytes, 0x20)\n            } lt(mc, end) {\n                // Increase both counters by 32 bytes each iteration.\n                mc := add(mc, 0x20)\n                cc := add(cc, 0x20)\n            } {\n                // Write the _preBytes data into the tempBytes memory 32 bytes\n                // at a time.\n                mstore(mc, mload(cc))\n            }\n\n            // Add the length of _postBytes to the current length of tempBytes\n            // and store it as the new length in the first 32 bytes of the\n            // tempBytes memory.\n            length := mload(_postBytes)\n            mstore(tempBytes, add(length, mload(tempBytes)))\n\n            // Move the memory counter back from a multiple of 0x20 to the\n            // actual end of the _preBytes data.\n            mc := end\n            // Stop copying when the memory counter reaches the new combined\n            // length of the arrays.\n            end := add(mc, length)\n\n            for {\n                let cc := add(_postBytes, 0x20)\n            } lt(mc, end) {\n                mc := add(mc, 0x20)\n                cc := add(cc, 0x20)\n            } {\n                mstore(mc, mload(cc))\n            }\n\n            // Update the free-memory pointer by padding our last write location\n            // to 32 bytes: add 31 bytes to the end of tempBytes to move to the\n            // next 32 byte block, then round down to the nearest multiple of\n            // 32. If the sum of the length of the two arrays is zero then add\n            // one before rounding down to leave a blank 32 bytes (the length block with 0).\n            mstore(0x40, and(\n              add(add(end, iszero(add(length, mload(_preBytes)))), 31),\n              not(31) // Round down to the nearest 32 bytes.\n            ))\n        }\n\n        return tempBytes;\n    }\n\n    function concatStorage(bytes storage _preBytes, bytes memory _postBytes) internal {\n        assembly {\n            // Read the first 32 bytes of _preBytes storage, which is the length\n            // of the array. (We don't need to use the offset into the slot\n            // because arrays use the entire slot.)\n            let fslot := sload(_preBytes.slot)\n            // Arrays of 31 bytes or less have an even value in their slot,\n            // while longer arrays have an odd value. The actual length is\n            // the slot divided by two for odd values, and the lowest order\n            // byte divided by two for even values.\n            // If the slot is even, bitwise and the slot with 255 and divide by\n            // two to get the length. If the slot is odd, bitwise and the slot\n            // with -1 and divide by two.\n            let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)\n            let mlength := mload(_postBytes)\n            let newlength := add(slength, mlength)\n            // slength can contain both the length and contents of the array\n            // if length < 32 bytes so let's prepare for that\n            // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage\n            switch add(lt(slength, 32), lt(newlength, 32))\n            case 2 {\n                // Since the new array still fits in the slot, we just need to\n                // update the contents of the slot.\n                // uint256(bytes_storage) = uint256(bytes_storage) + uint256(bytes_memory) + new_length\n                sstore(\n                    _preBytes.slot,\n                    // all the modifications to the slot are inside this\n                    // next block\n                    add(\n                        // we can just add to the slot contents because the\n                        // bytes we want to change are the LSBs\n                        fslot,\n                        add(\n                            mul(\n                                div(\n                                    // load the bytes from memory\n                                    mload(add(_postBytes, 0x20)),\n                                    // zero all bytes to the right\n                                    exp(0x100, sub(32, mlength))\n                                ),\n                                // and now shift left the number of bytes to\n                                // leave space for the length in the slot\n                                exp(0x100, sub(32, newlength))\n                            ),\n                            // increase length by the double of the memory\n                            // bytes length\n                            mul(mlength, 2)\n                        )\n                    )\n                )\n            }\n            case 1 {\n                // The stored value fits in the slot, but the combined value\n                // will exceed it.\n                // get the keccak hash to get the contents of the array\n                mstore(0x0, _preBytes.slot)\n                let sc := add(keccak256(0x0, 0x20), div(slength, 32))\n\n                // save new length\n                sstore(_preBytes.slot, add(mul(newlength, 2), 1))\n\n                // The contents of the _postBytes array start 32 bytes into\n                // the structure. Our first read should obtain the `submod`\n                // bytes that can fit into the unused space in the last word\n                // of the stored array. To get this, we read 32 bytes starting\n                // from `submod`, so the data we read overlaps with the array\n                // contents by `submod` bytes. Masking the lowest-order\n                // `submod` bytes allows us to add that value directly to the\n                // stored value.\n\n                let submod := sub(32, slength)\n                let mc := add(_postBytes, submod)\n                let end := add(_postBytes, mlength)\n                let mask := sub(exp(0x100, submod), 1)\n\n                sstore(\n                    sc,\n                    add(\n                        and(\n                            fslot,\n                            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00\n                        ),\n                        and(mload(mc), mask)\n                    )\n                )\n\n                for {\n                    mc := add(mc, 0x20)\n                    sc := add(sc, 1)\n                } lt(mc, end) {\n                    sc := add(sc, 1)\n                    mc := add(mc, 0x20)\n                } {\n                    sstore(sc, mload(mc))\n                }\n\n                mask := exp(0x100, sub(mc, end))\n\n                sstore(sc, mul(div(mload(mc), mask), mask))\n            }\n            default {\n                // get the keccak hash to get the contents of the array\n                mstore(0x0, _preBytes.slot)\n                // Start copying to the last used word of the stored array.\n                let sc := add(keccak256(0x0, 0x20), div(slength, 32))\n\n                // save new length\n                sstore(_preBytes.slot, add(mul(newlength, 2), 1))\n\n                // Copy over the first `submod` bytes of the new data as in\n                // case 1 above.\n                let slengthmod := mod(slength, 32)\n                let mlengthmod := mod(mlength, 32)\n                let submod := sub(32, slengthmod)\n                let mc := add(_postBytes, submod)\n                let end := add(_postBytes, mlength)\n                let mask := sub(exp(0x100, submod), 1)\n\n                sstore(sc, add(sload(sc), and(mload(mc), mask)))\n\n                for {\n                    sc := add(sc, 1)\n                    mc := add(mc, 0x20)\n                } lt(mc, end) {\n                    sc := add(sc, 1)\n                    mc := add(mc, 0x20)\n                } {\n                    sstore(sc, mload(mc))\n                }\n\n                mask := exp(0x100, sub(mc, end))\n\n                sstore(sc, mul(div(mload(mc), mask), mask))\n            }\n        }\n    }\n\n    function slice(\n        bytes memory _bytes,\n        uint256 _start,\n        uint256 _length\n    )\n        internal\n        pure\n        returns (bytes memory)\n    {\n        require(_length + 31 >= _length, \"slice_overflow\");\n        require(_bytes.length >= _start + _length, \"slice_outOfBounds\");\n\n        bytes memory tempBytes;\n\n        assembly {\n            switch iszero(_length)\n            case 0 {\n                // Get a location of some free memory and store it in tempBytes as\n                // Solidity does for memory variables.\n                tempBytes := mload(0x40)\n\n                // The first word of the slice result is potentially a partial\n                // word read from the original array. To read it, we calculate\n                // the length of that partial word and start copying that many\n                // bytes into the array. The first word we copy will start with\n                // data we don't care about, but the last `lengthmod` bytes will\n                // land at the beginning of the contents of the new array. When\n                // we're done copying, we overwrite the full first word with\n                // the actual length of the slice.\n                let lengthmod := and(_length, 31)\n\n                // The multiplication in the next line is necessary\n                // because when slicing multiples of 32 bytes (lengthmod == 0)\n                // the following copy loop was copying the origin's length\n                // and then ending prematurely not copying everything it should.\n                let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))\n                let end := add(mc, _length)\n\n                for {\n                    // The multiplication in the next line has the same exact purpose\n                    // as the one above.\n                    let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)\n                } lt(mc, end) {\n                    mc := add(mc, 0x20)\n                    cc := add(cc, 0x20)\n                } {\n                    mstore(mc, mload(cc))\n                }\n\n                mstore(tempBytes, _length)\n\n                //update free-memory pointer\n                //allocating the array padded to 32 bytes like the compiler does now\n                mstore(0x40, and(add(mc, 31), not(31)))\n            }\n            //if we want a zero-length slice let's just return a zero-length array\n            default {\n                tempBytes := mload(0x40)\n                //zero out the 32 bytes slice we are about to return\n                //we need to do it because Solidity does not garbage collect\n                mstore(tempBytes, 0)\n\n                mstore(0x40, add(tempBytes, 0x20))\n            }\n        }\n\n        return tempBytes;\n    }\n\n    function toAddress(bytes memory _bytes, uint256 _start) internal pure returns (address) {\n        require(_bytes.length >= _start + 20, \"toAddress_outOfBounds\");\n        address tempAddress;\n\n        assembly {\n            tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)\n        }\n\n        return tempAddress;\n    }\n\n    function toUint8(bytes memory _bytes, uint256 _start) internal pure returns (uint8) {\n        require(_bytes.length >= _start + 1 , \"toUint8_outOfBounds\");\n        uint8 tempUint;\n\n        assembly {\n            tempUint := mload(add(add(_bytes, 0x1), _start))\n        }\n\n        return tempUint;\n    }\n\n    function toUint16(bytes memory _bytes, uint256 _start) internal pure returns (uint16) {\n        require(_bytes.length >= _start + 2, \"toUint16_outOfBounds\");\n        uint16 tempUint;\n\n        assembly {\n            tempUint := mload(add(add(_bytes, 0x2), _start))\n        }\n\n        return tempUint;\n    }\n\n    function toUint32(bytes memory _bytes, uint256 _start) internal pure returns (uint32) {\n        require(_bytes.length >= _start + 4, \"toUint32_outOfBounds\");\n        uint32 tempUint;\n\n        assembly {\n            tempUint := mload(add(add(_bytes, 0x4), _start))\n        }\n\n        return tempUint;\n    }\n\n    function toUint64(bytes memory _bytes, uint256 _start) internal pure returns (uint64) {\n        require(_bytes.length >= _start + 8, \"toUint64_outOfBounds\");\n        uint64 tempUint;\n\n        assembly {\n            tempUint := mload(add(add(_bytes, 0x8), _start))\n        }\n\n        return tempUint;\n    }\n\n    function toUint96(bytes memory _bytes, uint256 _start) internal pure returns (uint96) {\n        require(_bytes.length >= _start + 12, \"toUint96_outOfBounds\");\n        uint96 tempUint;\n\n        assembly {\n            tempUint := mload(add(add(_bytes, 0xc), _start))\n        }\n\n        return tempUint;\n    }\n\n    function toUint128(bytes memory _bytes, uint256 _start) internal pure returns (uint128) {\n        require(_bytes.length >= _start + 16, \"toUint128_outOfBounds\");\n        uint128 tempUint;\n\n        assembly {\n            tempUint := mload(add(add(_bytes, 0x10), _start))\n        }\n\n        return tempUint;\n    }\n\n    function toUint256(bytes memory _bytes, uint256 _start) internal pure returns (uint256) {\n        require(_bytes.length >= _start + 32, \"toUint256_outOfBounds\");\n        uint256 tempUint;\n\n        assembly {\n            tempUint := mload(add(add(_bytes, 0x20), _start))\n        }\n\n        return tempUint;\n    }\n\n    function toBytes32(bytes memory _bytes, uint256 _start) internal pure returns (bytes32) {\n        require(_bytes.length >= _start + 32, \"toBytes32_outOfBounds\");\n        bytes32 tempBytes32;\n\n        assembly {\n            tempBytes32 := mload(add(add(_bytes, 0x20), _start))\n        }\n\n        return tempBytes32;\n    }\n\n    function equal(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool) {\n        bool success = true;\n\n        assembly {\n            let length := mload(_preBytes)\n\n            // if lengths don't match the arrays are not equal\n            switch eq(length, mload(_postBytes))\n            case 1 {\n                // cb is a circuit breaker in the for loop since there's\n                //  no said feature for inline assembly loops\n                // cb = 1 - don't breaker\n                // cb = 0 - break\n                let cb := 1\n\n                let mc := add(_preBytes, 0x20)\n                let end := add(mc, length)\n\n                for {\n                    let cc := add(_postBytes, 0x20)\n                // the next line is the loop condition:\n                // while(uint256(mc < end) + cb == 2)\n                } eq(add(lt(mc, end), cb), 2) {\n                    mc := add(mc, 0x20)\n                    cc := add(cc, 0x20)\n                } {\n                    // if any of these checks fails then arrays are not equal\n                    if iszero(eq(mload(mc), mload(cc))) {\n                        // unsuccess:\n                        success := 0\n                        cb := 0\n                    }\n                }\n            }\n            default {\n                // unsuccess:\n                success := 0\n            }\n        }\n\n        return success;\n    }\n\n    function equalStorage(\n        bytes storage _preBytes,\n        bytes memory _postBytes\n    )\n        internal\n        view\n        returns (bool)\n    {\n        bool success = true;\n\n        assembly {\n            // we know _preBytes_offset is 0\n            let fslot := sload(_preBytes.slot)\n            // Decode the length of the stored array like in concatStorage().\n            let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)\n            let mlength := mload(_postBytes)\n\n            // if lengths don't match the arrays are not equal\n            switch eq(slength, mlength)\n            case 1 {\n                // slength can contain both the length and contents of the array\n                // if length < 32 bytes so let's prepare for that\n                // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage\n                if iszero(iszero(slength)) {\n                    switch lt(slength, 32)\n                    case 1 {\n                        // blank the last byte which is the length\n                        fslot := mul(div(fslot, 0x100), 0x100)\n\n                        if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) {\n                            // unsuccess:\n                            success := 0\n                        }\n                    }\n                    default {\n                        // cb is a circuit breaker in the for loop since there's\n                        //  no said feature for inline assembly loops\n                        // cb = 1 - don't breaker\n                        // cb = 0 - break\n                        let cb := 1\n\n                        // get the keccak hash to get the contents of the array\n                        mstore(0x0, _preBytes.slot)\n                        let sc := keccak256(0x0, 0x20)\n\n                        let mc := add(_postBytes, 0x20)\n                        let end := add(mc, mlength)\n\n                        // the next line is the loop condition:\n                        // while(uint256(mc < end) + cb == 2)\n                        for {} eq(add(lt(mc, end), cb), 2) {\n                            sc := add(sc, 1)\n                            mc := add(mc, 0x20)\n                        } {\n                            if iszero(eq(sload(sc), mload(mc))) {\n                                // unsuccess:\n                                success := 0\n                                cb := 0\n                            }\n                        }\n                    }\n                }\n            }\n            default {\n                // unsuccess:\n                success := 0\n            }\n        }\n\n        return success;\n    }\n}\n"},"src/MayanForwarder.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol\";\nimport \"./libs/BytesLib.sol\";\n\n\ncontract MayanForwarder2 {\n\n\tusing SafeERC20 for IERC20;\n\tusing BytesLib for bytes;\n\n\tevent SwapAndForwarded(uint256 amount);\n\n\taddress public guardian;\n\taddress public nextGuardian;\n\tmapping(address => bool) public swapProtocols;\n\tmapping(address => bool) public mayanProtocols;\n\n\tevent ForwardedEth(address mayanProtocol, bytes protocolData);\n\tevent ForwardedERC20(address token, uint256 amount, address mayanProtocol, bytes protocolData);\n\tevent SwapAndForwardedEth(uint256 amountIn, address swapProtocol, address middleToken, uint256 middleAmount, address mayanProtocol, bytes mayanData);\n\tevent SwapAndForwardedERC20(address tokenIn, uint256 amountIn, address swapProtocol, address middleToken, uint256 middleAmount, address mayanProtocol, bytes mayanData);\n\n\terror UnsupportedProtocol();\n\n\tstruct PermitParams {\n\t\tuint256 value;\n\t\tuint256 deadline;\n\t\tuint8 v;\n\t\tbytes32 r;\n\t\tbytes32 s;\n\t}\n\n\tconstructor(address _guardian, address[] memory _swapProtocols, address[] memory _mayanProtocols) {\n\t\tguardian = _guardian;\n\t\tfor (uint256 i = 0; i < _swapProtocols.length; i++) {\n\t\t\tswapProtocols[_swapProtocols[i]] = true;\n\t\t}\n\t\tfor (uint256 i = 0; i < _mayanProtocols.length; i++) {\n\t\t\tmayanProtocols[_mayanProtocols[i]] = true;\n\t\t}\n\t}\n\n\tfunction forwardEth(\n\t\taddress mayanProtocol,\n\t\tbytes calldata protocolData\n\t) external payable {\n\t\tif (!mayanProtocols[mayanProtocol]) {\n\t\t\trevert UnsupportedProtocol();\n\t\t}\n\t\t(bool success, ) = mayanProtocol.call{value: msg.value}(protocolData);\n\t\trequire(success, \"mayan protocol call failed\");\n\n\t\temit ForwardedEth(mayanProtocol, protocolData);\n\t}\n\t\n\tfunction forwardERC20(\n\t\taddress tokenIn,\n\t\tuint256 amountIn,\n\t\tPermitParams calldata permitParams,\n\t\taddress mayanProtocol,\n\t\tbytes calldata protocolData\n\t\t) external payable {\n\t\tif (!mayanProtocols[mayanProtocol]) {\n\t\t\trevert UnsupportedProtocol();\n\t\t}\n\n\t\tpullTokenIn(tokenIn, amountIn, permitParams);\n\n\t\tmaxApproveIfNeeded(tokenIn, mayanProtocol, amountIn);\n\t\t(bool success, ) = mayanProtocol.call{value: msg.value}(protocolData);\n\t\trequire(success, \"mayan protocol call failed\");\n\n\t\temit ForwardedERC20(tokenIn, amountIn, mayanProtocol, protocolData);\n\t}\n\n\tfunction swapAndForwardEth(\n\t\tuint256 amountIn,\n\t\taddress swapProtocol,\n\t\tbytes calldata swapData,\n\t\taddress middleToken,\n\t\tuint256 minMiddleAmount,\n\t\taddress mayanProtocol,\n\t\tbytes calldata mayanData\n\t) external payable {\n\t\tif (!swapProtocols[swapProtocol] || !mayanProtocols[mayanProtocol]) {\n\t\t\trevert UnsupportedProtocol();\n\t\t}\n\t\trequire(middleToken != address(0), \"middleToken cannot be zero address\");\n\n\t\trequire(msg.value >= amountIn, \"insufficient amountIn\");\n\t\tuint256 middleAmount = IERC20(middleToken).balanceOf(address(this));\n\n\t\t(bool success, ) = swapProtocol.call{value: amountIn}(swapData);\n\t\trequire(success, \"swap call failed\");\n\n\t\tmiddleAmount = IERC20(middleToken).balanceOf(address(this)) - middleAmount;\n\t\trequire(middleAmount >= minMiddleAmount, \"insufficient middle token\");\n\n\t\tmaxApproveIfNeeded(middleToken, mayanProtocol, middleAmount);\n\n\t\tbytes memory modifiedData = replaceMiddleAmount(mayanData, middleAmount);\n\t\t(success, ) = mayanProtocol.call{value: msg.value - amountIn}(modifiedData);\n\t\trequire(success, \"mayan protocol call failed\");\n\n\t\temit SwapAndForwardedEth(amountIn, swapProtocol, middleToken, middleAmount, mayanProtocol, mayanData);\n\t}\n\n\tfunction swapAndForwardERC20(\n\t\taddress tokenIn,\n\t\tuint256 amountIn,\n\t\tPermitParams calldata permitParams,\n\t\taddress swapProtocol,\n\t\tbytes calldata swapData,\n\t\taddress middleToken,\n\t\tuint256 minMiddleAmount,\n\t\taddress mayanProtocol,\n\t\tbytes calldata mayanData\n\t) external payable {\n\t\tif (!swapProtocols[swapProtocol] || !mayanProtocols[mayanProtocol]) {\n\t\t\trevert UnsupportedProtocol();\n\t\t}\n\t\trequire(tokenIn != middleToken, \"tokenIn and tokenOut must be different\");\n\t\tuint256 amountBefore = IERC20(tokenIn).balanceOf(address(this));\n\t\tpullTokenIn(tokenIn, amountIn, permitParams);\n\n\t\tuint256 middleAmount;\n\t\tif (middleToken != address(0)) {\n\t\t\tmiddleAmount = IERC20(middleToken).balanceOf(address(this));\n\t\t} else {\n\t\t\tmiddleAmount = address(this).balance;\n\t\t}\n\n\t\tmaxApproveIfNeeded(tokenIn, swapProtocol, amountIn);\n\t\t(bool success, ) = swapProtocol.call{value: 0}(swapData);\n\t\trequire(success, \"swap protocol call failed\");\n\n\t\tif (middleToken != address(0)) {\n\t\t\tmiddleAmount = IERC20(middleToken).balanceOf(address(this)) - middleAmount;\n\t\t} else {\n\t\t\tmiddleAmount = address(this).balance - middleAmount;\n\t\t}\n\t\trequire(middleAmount >= minMiddleAmount, \"insufficient middle token\");\n\n\t\tuint256 val = msg.value;\n\t\tif (middleToken == address(0)) {\n\t\t\tval += middleAmount;\n\t\t} else {\n\t\t\tmaxApproveIfNeeded(middleToken, mayanProtocol, middleAmount);\n\t\t}\n\n\t\t(success, ) = mayanProtocol.call{value: val}(middleToken == address(0) ? mayanData : replaceMiddleAmount(mayanData, middleAmount));\n\t\trequire(success, \"mayan protocol call failed\");\n\n\t\ttransferBackRemaining(tokenIn, amountBefore);\n\n\t\temit SwapAndForwardedERC20(tokenIn, amountIn, swapProtocol, middleToken, middleAmount, mayanProtocol, mayanData);\n\t}\n\n\tfunction replaceMiddleAmount(bytes calldata mayanData, uint256 middleAmount) internal pure returns(bytes memory) {\n\t\trequire(mayanData.length >= 68, \"Mayan data too short\");\n\t\tbytes memory modifiedData = new bytes(mayanData.length);\n\n\t\t// Copy the function selector and token in\n\t\tfor (uint i = 0; i < 36; i++) {\n\t\t\tmodifiedData[i] = mayanData[i];\n\t\t}\n\n\t\t// Encode the amount and place it into the modified call data\n\t\t// Starting from byte 36 to byte 67 (32 bytes for uint256)\n\t\tbytes memory encodedAmount = abi.encode(middleAmount);\n\t\tfor (uint i = 0; i < 32; i++) {\n\t\t\tmodifiedData[i + 36] = encodedAmount[i];\n\t\t}\n\n\t\t// Copy the rest of the original data after the first argument\n\t\tfor (uint i = 68; i < mayanData.length; i++) {\n\t\t\tmodifiedData[i] = mayanData[i];\n\t\t}\n\n\t\treturn modifiedData;\n\t}\n\n\tfunction maxApproveIfNeeded(address tokenAddr, address spender, uint256 amount) internal {\n\t\tIERC20 token = IERC20(tokenAddr);\n\t\tuint256 currentAllowance = token.allowance(address(this), spender);\n\n\t\tif (currentAllowance < amount) {\n\t\t\ttoken.safeApprove(spender, 0);\n\t\t\ttoken.safeApprove(spender, type(uint256).max);\n\t\t}\n\t}\n\n\tfunction execPermit(\n\t\taddress token,\n\t\taddress owner,\n\t\tPermitParams calldata permitParams\n\t) internal {\n\t\tIERC20Permit(token).permit(\n\t\t\towner,\n\t\t\taddress(this),\n\t\t\tpermitParams.value,\n\t\t\tpermitParams.deadline,\n\t\t\tpermitParams.v,\n\t\t\tpermitParams.r,\n\t\t\tpermitParams.s\n\t\t);\n\t}\n\n\tfunction pullTokenIn(\n\t\taddress tokenIn,\n\t\tuint256 amountIn,\n\t\tPermitParams calldata permitParams\n\t) internal {\n\t\tuint256 allowance = IERC20(tokenIn).allowance(msg.sender, address(this));\n\t\tif (allowance < amountIn) {\n\t\t\texecPermit(tokenIn, msg.sender, permitParams);\n\t\t}\n\t\tIERC20(tokenIn).safeTransferFrom(msg.sender, address(this), amountIn);\n\t}\n\n\tfunction transferBackRemaining(address token, uint256 amountBefore) internal {\n\t\tuint256 remaining = IERC20(token).balanceOf(address(this));\n\t\tif (remaining > amountBefore) {\n\t\t\tIERC20(token).safeTransfer(msg.sender, remaining - amountBefore);\n\t\t}\n\t}\n\n\tfunction rescueToken(address token, uint256 amount, address to) public {\n\t\trequire(msg.sender == guardian, 'only guardian');\n\t\tIERC20(token).safeTransfer(to, amount);\n\t}\n\n\tfunction rescueEth(uint256 amount, address payable to) public {\n\t\trequire(msg.sender == guardian, 'only guardian');\n\t\trequire(to != address(0), 'transfer to the zero address');\n\t\t(bool success, ) = payable(to).call{value: amount}('');\n\t\trequire(success, 'payment failed');\n\t}\n\n\tfunction changeGuardian(address newGuardian) public {\n\t\trequire(msg.sender == guardian, 'only guardian');\n\t\tnextGuardian = newGuardian;\n\t}\n\n\tfunction claimGuardian() public {\n\t\trequire(msg.sender == nextGuardian, 'only next guardian');\n\t\tguardian = nextGuardian;\n\t}\n\n\tfunction setSwapProtocol(address swapProtocol, bool enabled) public {\n\t\trequire(msg.sender == guardian, 'only guardian');\n\t\tswapProtocols[swapProtocol] = enabled;\n\t}\n\n\tfunction setMayanProtocol(address mayanProtocol, bool enabled) public {\n\t\trequire(msg.sender == guardian, 'only guardian');\n\t\tmayanProtocols[mayanProtocol] = enabled;\n\t}\n\n\treceive() external payable {}\n}"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.4+commit.c7e474f2","compilerSettings":{"metadata":{"bytecodeHash":"ipfs"},"libraries":{},"optimizer":{"runs":800,"enabled":true},"evmVersion":"istanbul","remappings":[]},"name":"MayanForwarder2","fullyQualifiedName":"src/MayanForwarder.sol:MayanForwarder2"},"abi":[{"type":"constructor","inputs":[{"name":"_guardian","type":"address","internalType":"address"},{"name":"_swapProtocols","type":"address[]","internalType":"address[]"},{"name":"_mayanProtocols","type":"address[]","internalType":"address[]"}],"stateMutability":"nonpayable"},{"name":"UnsupportedProtocol","type":"error","inputs":[]},{"name":"ForwardedERC20","type":"event","inputs":[{"name":"token","type":"address","indexed":false,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"mayanProtocol","type":"address","indexed":false,"internalType":"address"},{"name":"protocolData","type":"bytes","indexed":false,"internalType":"bytes"}],"anonymous":false},{"name":"ForwardedEth","type":"event","inputs":[{"name":"mayanProtocol","type":"address","indexed":false,"internalType":"address"},{"name":"protocolData","type":"bytes","indexed":false,"internalType":"bytes"}],"anonymous":false},{"name":"SwapAndForwarded","type":"event","inputs":[{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"SwapAndForwardedERC20","type":"event","inputs":[{"name":"tokenIn","type":"address","indexed":false,"internalType":"address"},{"name":"amountIn","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"swapProtocol","type":"address","indexed":false,"internalType":"address"},{"name":"middleToken","type":"address","indexed":false,"internalType":"address"},{"name":"middleAmount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"mayanProtocol","type":"address","indexed":false,"internalType":"address"},{"name":"mayanData","type":"bytes","indexed":false,"internalType":"bytes"}],"anonymous":false},{"name":"SwapAndForwardedEth","type":"event","inputs":[{"name":"amountIn","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"swapProtocol","type":"address","indexed":false,"internalType":"address"},{"name":"middleToken","type":"address","indexed":false,"internalType":"address"},{"name":"middleAmount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"mayanProtocol","type":"address","indexed":false,"internalType":"address"},{"name":"mayanData","type":"bytes","indexed":false,"internalType":"bytes"}],"anonymous":false},{"name":"changeGuardian","type":"function","inputs":[{"name":"newGuardian","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"claimGuardian","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"forwardERC20","type":"function","inputs":[{"name":"tokenIn","type":"address","internalType":"address"},{"name":"amountIn","type":"uint256","internalType":"uint256"},{"name":"permitParams","type":"tuple","components":[{"name":"value","type":"uint256","internalType":"uint256"},{"name":"deadline","type":"uint256","internalType":"uint256"},{"name":"v","type":"uint8","internalType":"uint8"},{"name":"r","type":"bytes32","internalType":"bytes32"},{"name":"s","type":"bytes32","internalType":"bytes32"}],"internalType":"struct MayanForwarder2.PermitParams"},{"name":"mayanProtocol","type":"address","internalType":"address"},{"name":"protocolData","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"payable"},{"name":"forwardEth","type":"function","inputs":[{"name":"mayanProtocol","type":"address","internalType":"address"},{"name":"protocolData","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"payable"},{"name":"guardian","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"mayanProtocols","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"nextGuardian","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"rescueEth","type":"function","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"to","type":"address","internalType":"address payable"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"rescueToken","type":"function","inputs":[{"name":"token","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"to","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setMayanProtocol","type":"function","inputs":[{"name":"mayanProtocol","type":"address","internalType":"address"},{"name":"enabled","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setSwapProtocol","type":"function","inputs":[{"name":"swapProtocol","type":"address","internalType":"address"},{"name":"enabled","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"swapAndForwardERC20","type":"function","inputs":[{"name":"tokenIn","type":"address","internalType":"address"},{"name":"amountIn","type":"uint256","internalType":"uint256"},{"name":"permitParams","type":"tuple","components":[{"name":"value","type":"uint256","internalType":"uint256"},{"name":"deadline","type":"uint256","internalType":"uint256"},{"name":"v","type":"uint8","internalType":"uint8"},{"name":"r","type":"bytes32","internalType":"bytes32"},{"name":"s","type":"bytes32","internalType":"bytes32"}],"internalType":"struct MayanForwarder2.PermitParams"},{"name":"swapProtocol","type":"address","internalType":"address"},{"name":"swapData","type":"bytes","internalType":"bytes"},{"name":"middleToken","type":"address","internalType":"address"},{"name":"minMiddleAmount","type":"uint256","internalType":"uint256"},{"name":"mayanProtocol","type":"address","internalType":"address"},{"name":"mayanData","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"payable"},{"name":"swapAndForwardEth","type":"function","inputs":[{"name":"amountIn","type":"uint256","internalType":"uint256"},{"name":"swapProtocol","type":"address","internalType":"address"},{"name":"swapData","type":"bytes","internalType":"bytes"},{"name":"middleToken","type":"address","internalType":"address"},{"name":"minMiddleAmount","type":"uint256","internalType":"uint256"},{"name":"mayanProtocol","type":"address","internalType":"address"},{"name":"mayanData","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"payable"},{"name":"swapProtocols","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"type":"receive","stateMutability":"payable"}],"metadata":{"compiler":{"version":"0.8.4+commit.c7e474f2"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"_guardian","type":"address"},{"internalType":"address[]","name":"_swapProtocols","type":"address[]"},{"internalType":"address[]","name":"_mayanProtocols","type":"address[]"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"UnsupportedProtocol","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"address","name":"mayanProtocol","type":"address"},{"indexed":false,"internalType":"bytes","name":"protocolData","type":"bytes"}],"name":"ForwardedERC20","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"mayanProtocol","type":"address"},{"indexed":false,"internalType":"bytes","name":"protocolData","type":"bytes"}],"name":"ForwardedEth","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"SwapAndForwarded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"tokenIn","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountIn","type":"uint256"},{"indexed":false,"internalType":"address","name":"swapProtocol","type":"address"},{"indexed":false,"internalType":"address","name":"middleToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"middleAmount","type":"uint256"},{"indexed":false,"internalType":"address","name":"mayanProtocol","type":"address"},{"indexed":false,"internalType":"bytes","name":"mayanData","type":"bytes"}],"name":"SwapAndForwardedERC20","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amountIn","type":"uint256"},{"indexed":false,"internalType":"address","name":"swapProtocol","type":"address"},{"indexed":false,"internalType":"address","name":"middleToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"middleAmount","type":"uint256"},{"indexed":false,"internalType":"address","name":"mayanProtocol","type":"address"},{"indexed":false,"internalType":"bytes","name":"mayanData","type":"bytes"}],"name":"SwapAndForwardedEth","type":"event"},{"inputs":[{"internalType":"address","name":"newGuardian","type":"address"}],"name":"changeGuardian","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimGuardian","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"components":[{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"internalType":"struct MayanForwarder2.PermitParams","name":"permitParams","type":"tuple"},{"internalType":"address","name":"mayanProtocol","type":"address"},{"internalType":"bytes","name":"protocolData","type":"bytes"}],"name":"forwardERC20","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"mayanProtocol","type":"address"},{"internalType":"bytes","name":"protocolData","type":"bytes"}],"name":"forwardEth","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"guardian","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"mayanProtocols","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nextGuardian","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address payable","name":"to","type":"address"}],"name":"rescueEth","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"rescueToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"mayanProtocol","type":"address"},{"internalType":"bool","name":"enabled","type":"bool"}],"name":"setMayanProtocol","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"swapProtocol","type":"address"},{"internalType":"bool","name":"enabled","type":"bool"}],"name":"setSwapProtocol","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"components":[{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"internalType":"struct MayanForwarder2.PermitParams","name":"permitParams","type":"tuple"},{"internalType":"address","name":"swapProtocol","type":"address"},{"internalType":"bytes","name":"swapData","type":"bytes"},{"internalType":"address","name":"middleToken","type":"address"},{"internalType":"uint256","name":"minMiddleAmount","type":"uint256"},{"internalType":"address","name":"mayanProtocol","type":"address"},{"internalType":"bytes","name":"mayanData","type":"bytes"}],"name":"swapAndForwardERC20","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"address","name":"swapProtocol","type":"address"},{"internalType":"bytes","name":"swapData","type":"bytes"},{"internalType":"address","name":"middleToken","type":"address"},{"internalType":"uint256","name":"minMiddleAmount","type":"uint256"},{"internalType":"address","name":"mayanProtocol","type":"address"},{"internalType":"bytes","name":"mayanData","type":"bytes"}],"name":"swapAndForwardEth","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"swapProtocols","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"compilationTarget":{"src/MayanForwarder.sol":"MayanForwarder2"},"evmVersion":"istanbul","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":800},"remappings":[]},"sources":{"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"keccak256":"0x287b55befed2961a7eabd7d7b1b2839cbca8a5b80ef8dcbb25ed3d4c2002c305","license":"MIT","urls":["bzz-raw://bd39944e8fc06be6dbe2dd1d8449b5336e23c6a7ba3e8e9ae5ae0f37f35283f5","dweb:/ipfs/QmPV3FGYjVwvKSgAXKUN3r9T9GwniZz83CxBpM7vyj2G53"]},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol":{"keccak256":"0xec63854014a5b4f2b3290ab9103a21bdf902a508d0f41a8573fea49e98bf571a","license":"MIT","urls":["bzz-raw://bc5b5dc12fbc4002f282eaa7a5f06d8310ed62c1c77c5770f6283e058454c39a","dweb:/ipfs/Qme9rE2wS3yBuyJq9GgbmzbsBQsW2M2sVFqYYLw7bosGrv"]},"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol":{"keccak256":"0xabefac93435967b4d36a4fabcbdbb918d1f0b7ae3c3d85bc30923b326c927ed1","license":"MIT","urls":["bzz-raw://9d213d3befca47da33f6db0310826bcdb148299805c10d77175ecfe1d06a9a68","dweb:/ipfs/QmRgCn6SP1hbBkExUADFuDo8xkT4UU47yjNF5FhCeRbQmS"]},"@openzeppelin/contracts/utils/Address.sol":{"keccak256":"0x006dd67219697fe68d7fbfdea512e7c4cb64a43565ed86171d67e844982da6fa","license":"MIT","urls":["bzz-raw://2455248c8ddd9cc6a7af76a13973cddf222072427e7b0e2a7d1aff345145e931","dweb:/ipfs/QmfYjnjRbWqYpuxurqveE6HtzsY1Xx323J428AKQgtBJZm"]},"src/MayanForwarder.sol":{"keccak256":"0x85fb48683079499922a20d1259ac853f674c3c844c61c9082e296b94260f196a","license":"MIT","urls":["bzz-raw://9cfc40f8b6dff01ced03f40468cfca348be7aaa2b798981503a07392dabf52ea","dweb:/ipfs/QmTPd9QxMSXQ2EsvAYQPFye2Pw6JTgkDFT2pWHwTaNiH2v"]},"src/libs/BytesLib.sol":{"keccak256":"0xf75784dfc94ea43668eb195d5690a1dde1b6eda62017e73a3899721583821d29","license":"Unlicense","urls":["bzz-raw://ca16cef8b94f3ac75d376489a668618f6c4595a906b939d674a883f4bf426014","dweb:/ipfs/QmceGU7qhyFLSejaj6i4dEtMzXDCSF3aYDtW1UeKjXQaRn"]}},"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":838,"label":"guardian","offset":0,"contract":"src/MayanForwarder.sol:MayanForwarder2"},{"slot":"1","type":"t_address","astId":840,"label":"nextGuardian","offset":0,"contract":"src/MayanForwarder.sol:MayanForwarder2"},{"slot":"2","type":"t_mapping(t_address,t_bool)","astId":844,"label":"swapProtocols","offset":0,"contract":"src/MayanForwarder.sol:MayanForwarder2"},{"slot":"3","type":"t_mapping(t_address,t_bool)","astId":848,"label":"mayanProtocols","offset":0,"contract":"src/MayanForwarder.sol:MayanForwarder2"}]},"transientStorageLayout":null,"userdoc":{"kind":"user","methods":{},"version":1},"devdoc":{"kind":"dev","methods":{},"version":1},"sourceIds":{"src/libs/BytesLib.sol":{"id":5},"src/MayanForwarder.sol":{"id":4},"@openzeppelin/contracts/utils/Address.sol":{"id":3},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"id":0},"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol":{"id":2},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol":{"id":1}},"additionalInput":null,"stdJsonInput":{"sources":{"src/libs/BytesLib.sol":{"content":"// SPDX-License-Identifier: Unlicense\n/*\n * @title Solidity Bytes Arrays Utils\n * @author Gonçalo Sá <goncalo.sa@consensys.net>\n *\n * @dev Bytes tightly packed arrays utility library for ethereum contracts written in Solidity.\n *      The library lets you concatenate, slice and type cast bytes arrays both in memory and storage.\n */\npragma solidity >=0.8.0 <0.9.0;\n\n\nlibrary BytesLib {\n    function concat(\n        bytes memory _preBytes,\n        bytes memory _postBytes\n    )\n        internal\n        pure\n        returns (bytes memory)\n    {\n        bytes memory tempBytes;\n\n        assembly {\n            // Get a location of some free memory and store it in tempBytes as\n            // Solidity does for memory variables.\n            tempBytes := mload(0x40)\n\n            // Store the length of the first bytes array at the beginning of\n            // the memory for tempBytes.\n            let length := mload(_preBytes)\n            mstore(tempBytes, length)\n\n            // Maintain a memory counter for the current write location in the\n            // temp bytes array by adding the 32 bytes for the array length to\n            // the starting location.\n            let mc := add(tempBytes, 0x20)\n            // Stop copying when the memory counter reaches the length of the\n            // first bytes array.\n            let end := add(mc, length)\n\n            for {\n                // Initialize a copy counter to the start of the _preBytes data,\n                // 32 bytes into its memory.\n                let cc := add(_preBytes, 0x20)\n            } lt(mc, end) {\n                // Increase both counters by 32 bytes each iteration.\n                mc := add(mc, 0x20)\n                cc := add(cc, 0x20)\n            } {\n                // Write the _preBytes data into the tempBytes memory 32 bytes\n                // at a time.\n                mstore(mc, mload(cc))\n            }\n\n            // Add the length of _postBytes to the current length of tempBytes\n            // and store it as the new length in the first 32 bytes of the\n            // tempBytes memory.\n            length := mload(_postBytes)\n            mstore(tempBytes, add(length, mload(tempBytes)))\n\n            // Move the memory counter back from a multiple of 0x20 to the\n            // actual end of the _preBytes data.\n            mc := end\n            // Stop copying when the memory counter reaches the new combined\n            // length of the arrays.\n            end := add(mc, length)\n\n            for {\n                let cc := add(_postBytes, 0x20)\n            } lt(mc, end) {\n                mc := add(mc, 0x20)\n                cc := add(cc, 0x20)\n            } {\n                mstore(mc, mload(cc))\n            }\n\n            // Update the free-memory pointer by padding our last write location\n            // to 32 bytes: add 31 bytes to the end of tempBytes to move to the\n            // next 32 byte block, then round down to the nearest multiple of\n            // 32. If the sum of the length of the two arrays is zero then add\n            // one before rounding down to leave a blank 32 bytes (the length block with 0).\n            mstore(0x40, and(\n              add(add(end, iszero(add(length, mload(_preBytes)))), 31),\n              not(31) // Round down to the nearest 32 bytes.\n            ))\n        }\n\n        return tempBytes;\n    }\n\n    function concatStorage(bytes storage _preBytes, bytes memory _postBytes) internal {\n        assembly {\n            // Read the first 32 bytes of _preBytes storage, which is the length\n            // of the array. (We don't need to use the offset into the slot\n            // because arrays use the entire slot.)\n            let fslot := sload(_preBytes.slot)\n            // Arrays of 31 bytes or less have an even value in their slot,\n            // while longer arrays have an odd value. The actual length is\n            // the slot divided by two for odd values, and the lowest order\n            // byte divided by two for even values.\n            // If the slot is even, bitwise and the slot with 255 and divide by\n            // two to get the length. If the slot is odd, bitwise and the slot\n            // with -1 and divide by two.\n            let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)\n            let mlength := mload(_postBytes)\n            let newlength := add(slength, mlength)\n            // slength can contain both the length and contents of the array\n            // if length < 32 bytes so let's prepare for that\n            // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage\n            switch add(lt(slength, 32), lt(newlength, 32))\n            case 2 {\n                // Since the new array still fits in the slot, we just need to\n                // update the contents of the slot.\n                // uint256(bytes_storage) = uint256(bytes_storage) + uint256(bytes_memory) + new_length\n                sstore(\n                    _preBytes.slot,\n                    // all the modifications to the slot are inside this\n                    // next block\n                    add(\n                        // we can just add to the slot contents because the\n                        // bytes we want to change are the LSBs\n                        fslot,\n                        add(\n                            mul(\n                                div(\n                                    // load the bytes from memory\n                                    mload(add(_postBytes, 0x20)),\n                                    // zero all bytes to the right\n                                    exp(0x100, sub(32, mlength))\n                                ),\n                                // and now shift left the number of bytes to\n                                // leave space for the length in the slot\n                                exp(0x100, sub(32, newlength))\n                            ),\n                            // increase length by the double of the memory\n                            // bytes length\n                            mul(mlength, 2)\n                        )\n                    )\n                )\n            }\n            case 1 {\n                // The stored value fits in the slot, but the combined value\n                // will exceed it.\n                // get the keccak hash to get the contents of the array\n                mstore(0x0, _preBytes.slot)\n                let sc := add(keccak256(0x0, 0x20), div(slength, 32))\n\n                // save new length\n                sstore(_preBytes.slot, add(mul(newlength, 2), 1))\n\n                // The contents of the _postBytes array start 32 bytes into\n                // the structure. Our first read should obtain the `submod`\n                // bytes that can fit into the unused space in the last word\n                // of the stored array. To get this, we read 32 bytes starting\n                // from `submod`, so the data we read overlaps with the array\n                // contents by `submod` bytes. Masking the lowest-order\n                // `submod` bytes allows us to add that value directly to the\n                // stored value.\n\n                let submod := sub(32, slength)\n                let mc := add(_postBytes, submod)\n                let end := add(_postBytes, mlength)\n                let mask := sub(exp(0x100, submod), 1)\n\n                sstore(\n                    sc,\n                    add(\n                        and(\n                            fslot,\n                            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00\n                        ),\n                        and(mload(mc), mask)\n                    )\n                )\n\n                for {\n                    mc := add(mc, 0x20)\n                    sc := add(sc, 1)\n                } lt(mc, end) {\n                    sc := add(sc, 1)\n                    mc := add(mc, 0x20)\n                } {\n                    sstore(sc, mload(mc))\n                }\n\n                mask := exp(0x100, sub(mc, end))\n\n                sstore(sc, mul(div(mload(mc), mask), mask))\n            }\n            default {\n                // get the keccak hash to get the contents of the array\n                mstore(0x0, _preBytes.slot)\n                // Start copying to the last used word of the stored array.\n                let sc := add(keccak256(0x0, 0x20), div(slength, 32))\n\n                // save new length\n                sstore(_preBytes.slot, add(mul(newlength, 2), 1))\n\n                // Copy over the first `submod` bytes of the new data as in\n                // case 1 above.\n                let slengthmod := mod(slength, 32)\n                let mlengthmod := mod(mlength, 32)\n                let submod := sub(32, slengthmod)\n                let mc := add(_postBytes, submod)\n                let end := add(_postBytes, mlength)\n                let mask := sub(exp(0x100, submod), 1)\n\n                sstore(sc, add(sload(sc), and(mload(mc), mask)))\n\n                for {\n                    sc := add(sc, 1)\n                    mc := add(mc, 0x20)\n                } lt(mc, end) {\n                    sc := add(sc, 1)\n                    mc := add(mc, 0x20)\n                } {\n                    sstore(sc, mload(mc))\n                }\n\n                mask := exp(0x100, sub(mc, end))\n\n                sstore(sc, mul(div(mload(mc), mask), mask))\n            }\n        }\n    }\n\n    function slice(\n        bytes memory _bytes,\n        uint256 _start,\n        uint256 _length\n    )\n        internal\n        pure\n        returns (bytes memory)\n    {\n        require(_length + 31 >= _length, \"slice_overflow\");\n        require(_bytes.length >= _start + _length, \"slice_outOfBounds\");\n\n        bytes memory tempBytes;\n\n        assembly {\n            switch iszero(_length)\n            case 0 {\n                // Get a location of some free memory and store it in tempBytes as\n                // Solidity does for memory variables.\n                tempBytes := mload(0x40)\n\n                // The first word of the slice result is potentially a partial\n                // word read from the original array. To read it, we calculate\n                // the length of that partial word and start copying that many\n                // bytes into the array. The first word we copy will start with\n                // data we don't care about, but the last `lengthmod` bytes will\n                // land at the beginning of the contents of the new array. When\n                // we're done copying, we overwrite the full first word with\n                // the actual length of the slice.\n                let lengthmod := and(_length, 31)\n\n                // The multiplication in the next line is necessary\n                // because when slicing multiples of 32 bytes (lengthmod == 0)\n                // the following copy loop was copying the origin's length\n                // and then ending prematurely not copying everything it should.\n                let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))\n                let end := add(mc, _length)\n\n                for {\n                    // The multiplication in the next line has the same exact purpose\n                    // as the one above.\n                    let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)\n                } lt(mc, end) {\n                    mc := add(mc, 0x20)\n                    cc := add(cc, 0x20)\n                } {\n                    mstore(mc, mload(cc))\n                }\n\n                mstore(tempBytes, _length)\n\n                //update free-memory pointer\n                //allocating the array padded to 32 bytes like the compiler does now\n                mstore(0x40, and(add(mc, 31), not(31)))\n            }\n            //if we want a zero-length slice let's just return a zero-length array\n            default {\n                tempBytes := mload(0x40)\n                //zero out the 32 bytes slice we are about to return\n                //we need to do it because Solidity does not garbage collect\n                mstore(tempBytes, 0)\n\n                mstore(0x40, add(tempBytes, 0x20))\n            }\n        }\n\n        return tempBytes;\n    }\n\n    function toAddress(bytes memory _bytes, uint256 _start) internal pure returns (address) {\n        require(_bytes.length >= _start + 20, \"toAddress_outOfBounds\");\n        address tempAddress;\n\n        assembly {\n            tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)\n        }\n\n        return tempAddress;\n    }\n\n    function toUint8(bytes memory _bytes, uint256 _start) internal pure returns (uint8) {\n        require(_bytes.length >= _start + 1 , \"toUint8_outOfBounds\");\n        uint8 tempUint;\n\n        assembly {\n            tempUint := mload(add(add(_bytes, 0x1), _start))\n        }\n\n        return tempUint;\n    }\n\n    function toUint16(bytes memory _bytes, uint256 _start) internal pure returns (uint16) {\n        require(_bytes.length >= _start + 2, \"toUint16_outOfBounds\");\n        uint16 tempUint;\n\n        assembly {\n            tempUint := mload(add(add(_bytes, 0x2), _start))\n        }\n\n        return tempUint;\n    }\n\n    function toUint32(bytes memory _bytes, uint256 _start) internal pure returns (uint32) {\n        require(_bytes.length >= _start + 4, \"toUint32_outOfBounds\");\n        uint32 tempUint;\n\n        assembly {\n            tempUint := mload(add(add(_bytes, 0x4), _start))\n        }\n\n        return tempUint;\n    }\n\n    function toUint64(bytes memory _bytes, uint256 _start) internal pure returns (uint64) {\n        require(_bytes.length >= _start + 8, \"toUint64_outOfBounds\");\n        uint64 tempUint;\n\n        assembly {\n            tempUint := mload(add(add(_bytes, 0x8), _start))\n        }\n\n        return tempUint;\n    }\n\n    function toUint96(bytes memory _bytes, uint256 _start) internal pure returns (uint96) {\n        require(_bytes.length >= _start + 12, \"toUint96_outOfBounds\");\n        uint96 tempUint;\n\n        assembly {\n            tempUint := mload(add(add(_bytes, 0xc), _start))\n        }\n\n        return tempUint;\n    }\n\n    function toUint128(bytes memory _bytes, uint256 _start) internal pure returns (uint128) {\n        require(_bytes.length >= _start + 16, \"toUint128_outOfBounds\");\n        uint128 tempUint;\n\n        assembly {\n            tempUint := mload(add(add(_bytes, 0x10), _start))\n        }\n\n        return tempUint;\n    }\n\n    function toUint256(bytes memory _bytes, uint256 _start) internal pure returns (uint256) {\n        require(_bytes.length >= _start + 32, \"toUint256_outOfBounds\");\n        uint256 tempUint;\n\n        assembly {\n            tempUint := mload(add(add(_bytes, 0x20), _start))\n        }\n\n        return tempUint;\n    }\n\n    function toBytes32(bytes memory _bytes, uint256 _start) internal pure returns (bytes32) {\n        require(_bytes.length >= _start + 32, \"toBytes32_outOfBounds\");\n        bytes32 tempBytes32;\n\n        assembly {\n            tempBytes32 := mload(add(add(_bytes, 0x20), _start))\n        }\n\n        return tempBytes32;\n    }\n\n    function equal(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool) {\n        bool success = true;\n\n        assembly {\n            let length := mload(_preBytes)\n\n            // if lengths don't match the arrays are not equal\n            switch eq(length, mload(_postBytes))\n            case 1 {\n                // cb is a circuit breaker in the for loop since there's\n                //  no said feature for inline assembly loops\n                // cb = 1 - don't breaker\n                // cb = 0 - break\n                let cb := 1\n\n                let mc := add(_preBytes, 0x20)\n                let end := add(mc, length)\n\n                for {\n                    let cc := add(_postBytes, 0x20)\n                // the next line is the loop condition:\n                // while(uint256(mc < end) + cb == 2)\n                } eq(add(lt(mc, end), cb), 2) {\n                    mc := add(mc, 0x20)\n                    cc := add(cc, 0x20)\n                } {\n                    // if any of these checks fails then arrays are not equal\n                    if iszero(eq(mload(mc), mload(cc))) {\n                        // unsuccess:\n                        success := 0\n                        cb := 0\n                    }\n                }\n            }\n            default {\n                // unsuccess:\n                success := 0\n            }\n        }\n\n        return success;\n    }\n\n    function equalStorage(\n        bytes storage _preBytes,\n        bytes memory _postBytes\n    )\n        internal\n        view\n        returns (bool)\n    {\n        bool success = true;\n\n        assembly {\n            // we know _preBytes_offset is 0\n            let fslot := sload(_preBytes.slot)\n            // Decode the length of the stored array like in concatStorage().\n            let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)\n            let mlength := mload(_postBytes)\n\n            // if lengths don't match the arrays are not equal\n            switch eq(slength, mlength)\n            case 1 {\n                // slength can contain both the length and contents of the array\n                // if length < 32 bytes so let's prepare for that\n                // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage\n                if iszero(iszero(slength)) {\n                    switch lt(slength, 32)\n                    case 1 {\n                        // blank the last byte which is the length\n                        fslot := mul(div(fslot, 0x100), 0x100)\n\n                        if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) {\n                            // unsuccess:\n                            success := 0\n                        }\n                    }\n                    default {\n                        // cb is a circuit breaker in the for loop since there's\n                        //  no said feature for inline assembly loops\n                        // cb = 1 - don't breaker\n                        // cb = 0 - break\n                        let cb := 1\n\n                        // get the keccak hash to get the contents of the array\n                        mstore(0x0, _preBytes.slot)\n                        let sc := keccak256(0x0, 0x20)\n\n                        let mc := add(_postBytes, 0x20)\n                        let end := add(mc, mlength)\n\n                        // the next line is the loop condition:\n                        // while(uint256(mc < end) + cb == 2)\n                        for {} eq(add(lt(mc, end), cb), 2) {\n                            sc := add(sc, 1)\n                            mc := add(mc, 0x20)\n                        } {\n                            if iszero(eq(sload(sc), mload(mc))) {\n                                // unsuccess:\n                                success := 0\n                                cb := 0\n                            }\n                        }\n                    }\n                }\n            }\n            default {\n                // unsuccess:\n                success := 0\n            }\n        }\n\n        return success;\n    }\n}\n"},"src/MayanForwarder.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol\";\nimport \"./libs/BytesLib.sol\";\n\n\ncontract MayanForwarder2 {\n\n\tusing SafeERC20 for IERC20;\n\tusing BytesLib for bytes;\n\n\tevent SwapAndForwarded(uint256 amount);\n\n\taddress public guardian;\n\taddress public nextGuardian;\n\tmapping(address => bool) public swapProtocols;\n\tmapping(address => bool) public mayanProtocols;\n\n\tevent ForwardedEth(address mayanProtocol, bytes protocolData);\n\tevent ForwardedERC20(address token, uint256 amount, address mayanProtocol, bytes protocolData);\n\tevent SwapAndForwardedEth(uint256 amountIn, address swapProtocol, address middleToken, uint256 middleAmount, address mayanProtocol, bytes mayanData);\n\tevent SwapAndForwardedERC20(address tokenIn, uint256 amountIn, address swapProtocol, address middleToken, uint256 middleAmount, address mayanProtocol, bytes mayanData);\n\n\terror UnsupportedProtocol();\n\n\tstruct PermitParams {\n\t\tuint256 value;\n\t\tuint256 deadline;\n\t\tuint8 v;\n\t\tbytes32 r;\n\t\tbytes32 s;\n\t}\n\n\tconstructor(address _guardian, address[] memory _swapProtocols, address[] memory _mayanProtocols) {\n\t\tguardian = _guardian;\n\t\tfor (uint256 i = 0; i < _swapProtocols.length; i++) {\n\t\t\tswapProtocols[_swapProtocols[i]] = true;\n\t\t}\n\t\tfor (uint256 i = 0; i < _mayanProtocols.length; i++) {\n\t\t\tmayanProtocols[_mayanProtocols[i]] = true;\n\t\t}\n\t}\n\n\tfunction forwardEth(\n\t\taddress mayanProtocol,\n\t\tbytes calldata protocolData\n\t) external payable {\n\t\tif (!mayanProtocols[mayanProtocol]) {\n\t\t\trevert UnsupportedProtocol();\n\t\t}\n\t\t(bool success, ) = mayanProtocol.call{value: msg.value}(protocolData);\n\t\trequire(success, \"mayan protocol call failed\");\n\n\t\temit ForwardedEth(mayanProtocol, protocolData);\n\t}\n\t\n\tfunction forwardERC20(\n\t\taddress tokenIn,\n\t\tuint256 amountIn,\n\t\tPermitParams calldata permitParams,\n\t\taddress mayanProtocol,\n\t\tbytes calldata protocolData\n\t\t) external payable {\n\t\tif (!mayanProtocols[mayanProtocol]) {\n\t\t\trevert UnsupportedProtocol();\n\t\t}\n\n\t\tpullTokenIn(tokenIn, amountIn, permitParams);\n\n\t\tmaxApproveIfNeeded(tokenIn, mayanProtocol, amountIn);\n\t\t(bool success, ) = mayanProtocol.call{value: msg.value}(protocolData);\n\t\trequire(success, \"mayan protocol call failed\");\n\n\t\temit ForwardedERC20(tokenIn, amountIn, mayanProtocol, protocolData);\n\t}\n\n\tfunction swapAndForwardEth(\n\t\tuint256 amountIn,\n\t\taddress swapProtocol,\n\t\tbytes calldata swapData,\n\t\taddress middleToken,\n\t\tuint256 minMiddleAmount,\n\t\taddress mayanProtocol,\n\t\tbytes calldata mayanData\n\t) external payable {\n\t\tif (!swapProtocols[swapProtocol] || !mayanProtocols[mayanProtocol]) {\n\t\t\trevert UnsupportedProtocol();\n\t\t}\n\t\trequire(middleToken != address(0), \"middleToken cannot be zero address\");\n\n\t\trequire(msg.value >= amountIn, \"insufficient amountIn\");\n\t\tuint256 middleAmount = IERC20(middleToken).balanceOf(address(this));\n\n\t\t(bool success, ) = swapProtocol.call{value: amountIn}(swapData);\n\t\trequire(success, \"swap call failed\");\n\n\t\tmiddleAmount = IERC20(middleToken).balanceOf(address(this)) - middleAmount;\n\t\trequire(middleAmount >= minMiddleAmount, \"insufficient middle token\");\n\n\t\tmaxApproveIfNeeded(middleToken, mayanProtocol, middleAmount);\n\n\t\tbytes memory modifiedData = replaceMiddleAmount(mayanData, middleAmount);\n\t\t(success, ) = mayanProtocol.call{value: msg.value - amountIn}(modifiedData);\n\t\trequire(success, \"mayan protocol call failed\");\n\n\t\temit SwapAndForwardedEth(amountIn, swapProtocol, middleToken, middleAmount, mayanProtocol, mayanData);\n\t}\n\n\tfunction swapAndForwardERC20(\n\t\taddress tokenIn,\n\t\tuint256 amountIn,\n\t\tPermitParams calldata permitParams,\n\t\taddress swapProtocol,\n\t\tbytes calldata swapData,\n\t\taddress middleToken,\n\t\tuint256 minMiddleAmount,\n\t\taddress mayanProtocol,\n\t\tbytes calldata mayanData\n\t) external payable {\n\t\tif (!swapProtocols[swapProtocol] || !mayanProtocols[mayanProtocol]) {\n\t\t\trevert UnsupportedProtocol();\n\t\t}\n\t\trequire(tokenIn != middleToken, \"tokenIn and tokenOut must be different\");\n\t\tuint256 amountBefore = IERC20(tokenIn).balanceOf(address(this));\n\t\tpullTokenIn(tokenIn, amountIn, permitParams);\n\n\t\tuint256 middleAmount;\n\t\tif (middleToken != address(0)) {\n\t\t\tmiddleAmount = IERC20(middleToken).balanceOf(address(this));\n\t\t} else {\n\t\t\tmiddleAmount = address(this).balance;\n\t\t}\n\n\t\tmaxApproveIfNeeded(tokenIn, swapProtocol, amountIn);\n\t\t(bool success, ) = swapProtocol.call{value: 0}(swapData);\n\t\trequire(success, \"swap protocol call failed\");\n\n\t\tif (middleToken != address(0)) {\n\t\t\tmiddleAmount = IERC20(middleToken).balanceOf(address(this)) - middleAmount;\n\t\t} else {\n\t\t\tmiddleAmount = address(this).balance - middleAmount;\n\t\t}\n\t\trequire(middleAmount >= minMiddleAmount, \"insufficient middle token\");\n\n\t\tuint256 val = msg.value;\n\t\tif (middleToken == address(0)) {\n\t\t\tval += middleAmount;\n\t\t} else {\n\t\t\tmaxApproveIfNeeded(middleToken, mayanProtocol, middleAmount);\n\t\t}\n\n\t\t(success, ) = mayanProtocol.call{value: val}(middleToken == address(0) ? mayanData : replaceMiddleAmount(mayanData, middleAmount));\n\t\trequire(success, \"mayan protocol call failed\");\n\n\t\ttransferBackRemaining(tokenIn, amountBefore);\n\n\t\temit SwapAndForwardedERC20(tokenIn, amountIn, swapProtocol, middleToken, middleAmount, mayanProtocol, mayanData);\n\t}\n\n\tfunction replaceMiddleAmount(bytes calldata mayanData, uint256 middleAmount) internal pure returns(bytes memory) {\n\t\trequire(mayanData.length >= 68, \"Mayan data too short\");\n\t\tbytes memory modifiedData = new bytes(mayanData.length);\n\n\t\t// Copy the function selector and token in\n\t\tfor (uint i = 0; i < 36; i++) {\n\t\t\tmodifiedData[i] = mayanData[i];\n\t\t}\n\n\t\t// Encode the amount and place it into the modified call data\n\t\t// Starting from byte 36 to byte 67 (32 bytes for uint256)\n\t\tbytes memory encodedAmount = abi.encode(middleAmount);\n\t\tfor (uint i = 0; i < 32; i++) {\n\t\t\tmodifiedData[i + 36] = encodedAmount[i];\n\t\t}\n\n\t\t// Copy the rest of the original data after the first argument\n\t\tfor (uint i = 68; i < mayanData.length; i++) {\n\t\t\tmodifiedData[i] = mayanData[i];\n\t\t}\n\n\t\treturn modifiedData;\n\t}\n\n\tfunction maxApproveIfNeeded(address tokenAddr, address spender, uint256 amount) internal {\n\t\tIERC20 token = IERC20(tokenAddr);\n\t\tuint256 currentAllowance = token.allowance(address(this), spender);\n\n\t\tif (currentAllowance < amount) {\n\t\t\ttoken.safeApprove(spender, 0);\n\t\t\ttoken.safeApprove(spender, type(uint256).max);\n\t\t}\n\t}\n\n\tfunction execPermit(\n\t\taddress token,\n\t\taddress owner,\n\t\tPermitParams calldata permitParams\n\t) internal {\n\t\tIERC20Permit(token).permit(\n\t\t\towner,\n\t\t\taddress(this),\n\t\t\tpermitParams.value,\n\t\t\tpermitParams.deadline,\n\t\t\tpermitParams.v,\n\t\t\tpermitParams.r,\n\t\t\tpermitParams.s\n\t\t);\n\t}\n\n\tfunction pullTokenIn(\n\t\taddress tokenIn,\n\t\tuint256 amountIn,\n\t\tPermitParams calldata permitParams\n\t) internal {\n\t\tuint256 allowance = IERC20(tokenIn).allowance(msg.sender, address(this));\n\t\tif (allowance < amountIn) {\n\t\t\texecPermit(tokenIn, msg.sender, permitParams);\n\t\t}\n\t\tIERC20(tokenIn).safeTransferFrom(msg.sender, address(this), amountIn);\n\t}\n\n\tfunction transferBackRemaining(address token, uint256 amountBefore) internal {\n\t\tuint256 remaining = IERC20(token).balanceOf(address(this));\n\t\tif (remaining > amountBefore) {\n\t\t\tIERC20(token).safeTransfer(msg.sender, remaining - amountBefore);\n\t\t}\n\t}\n\n\tfunction rescueToken(address token, uint256 amount, address to) public {\n\t\trequire(msg.sender == guardian, 'only guardian');\n\t\tIERC20(token).safeTransfer(to, amount);\n\t}\n\n\tfunction rescueEth(uint256 amount, address payable to) public {\n\t\trequire(msg.sender == guardian, 'only guardian');\n\t\trequire(to != address(0), 'transfer to the zero address');\n\t\t(bool success, ) = payable(to).call{value: amount}('');\n\t\trequire(success, 'payment failed');\n\t}\n\n\tfunction changeGuardian(address newGuardian) public {\n\t\trequire(msg.sender == guardian, 'only guardian');\n\t\tnextGuardian = newGuardian;\n\t}\n\n\tfunction claimGuardian() public {\n\t\trequire(msg.sender == nextGuardian, 'only next guardian');\n\t\tguardian = nextGuardian;\n\t}\n\n\tfunction setSwapProtocol(address swapProtocol, bool enabled) public {\n\t\trequire(msg.sender == guardian, 'only guardian');\n\t\tswapProtocols[swapProtocol] = enabled;\n\t}\n\n\tfunction setMayanProtocol(address mayanProtocol, bool enabled) public {\n\t\trequire(msg.sender == guardian, 'only guardian');\n\t\tmayanProtocols[mayanProtocol] = enabled;\n\t}\n\n\treceive() external payable {}\n}"},"@openzeppelin/contracts/utils/Address.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.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"},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the amount of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the amount of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves `amount` tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Moves `amount` tokens from `from` to `to` using the\n     * allowance mechanism. `amount` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 amount) external returns (bool);\n}\n"},"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\nimport \"../extensions/IERC20Permit.sol\";\nimport \"../../../utils/Address.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n    using Address for address;\n\n    /**\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     */\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\n        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\n    }\n\n    /**\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\n     */\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\n        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\n    }\n\n    /**\n     * @dev Deprecated. This function has issues similar to the ones found in\n     * {IERC20-approve}, and its usage is discouraged.\n     *\n     * Whenever possible, use {safeIncreaseAllowance} and\n     * {safeDecreaseAllowance} instead.\n     */\n    function safeApprove(IERC20 token, address spender, uint256 value) internal {\n        // safeApprove should only be called when setting an initial allowance,\n        // or when resetting it to zero. To increase and decrease it, use\n        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\n        require(\n            (value == 0) || (token.allowance(address(this), spender) == 0),\n            \"SafeERC20: approve from non-zero to non-zero allowance\"\n        );\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\n    }\n\n    /**\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     */\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 oldAllowance = token.allowance(address(this), spender);\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));\n    }\n\n    /**\n     * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     */\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        unchecked {\n            uint256 oldAllowance = token.allowance(address(this), spender);\n            require(oldAllowance >= value, \"SafeERC20: decreased allowance below zero\");\n            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));\n        }\n    }\n\n    /**\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\n     * to be set to zero before setting it to a non-zero value, such as USDT.\n     */\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\n        bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);\n\n        if (!_callOptionalReturnBool(token, approvalCall)) {\n            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));\n            _callOptionalReturn(token, approvalCall);\n        }\n    }\n\n    /**\n     * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.\n     * Revert on invalid signature.\n     */\n    function safePermit(\n        IERC20Permit token,\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal {\n        uint256 nonceBefore = token.nonces(owner);\n        token.permit(owner, spender, value, deadline, v, r, s);\n        uint256 nonceAfter = token.nonces(owner);\n        require(nonceAfter == nonceBefore + 1, \"SafeERC20: permit did not succeed\");\n    }\n\n    /**\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\n     * @param token The token targeted by the call.\n     * @param data The call data (encoded using abi.encode or one of its variants).\n     */\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\n        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\n        // the target address contains contract code and also asserts for success in the low-level call.\n\n        bytes memory returndata = address(token).functionCall(data, \"SafeERC20: low-level call failed\");\n        require(returndata.length == 0 || abi.decode(returndata, (bool)), \"SafeERC20: ERC20 operation did not succeed\");\n    }\n\n    /**\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\n     * @param token The token targeted by the call.\n     * @param data The call data (encoded using abi.encode or one of its variants).\n     *\n     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.\n     */\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\n        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false\n        // and not revert is the subcall reverts.\n\n        (bool success, bytes memory returndata) = address(token).call(data);\n        return\n            success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));\n    }\n}\n"},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/IERC20Permit.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n */\ninterface IERC20Permit {\n    /**\n     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\n     * given ``owner``'s signed approval.\n     *\n     * IMPORTANT: The same issues {IERC20-approve} has related to transaction\n     * ordering also apply here.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `deadline` must be a timestamp in the future.\n     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\n     * over the EIP712-formatted function arguments.\n     * - the signature must use ``owner``'s current nonce (see {nonces}).\n     *\n     * For more information on the signature format, see the\n     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\n     * section].\n     */\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external;\n\n    /**\n     * @dev Returns the current nonce for `owner`. This value must be\n     * included whenever a signature is generated for {permit}.\n     *\n     * Every successful call to {permit} increases ``owner``'s nonce by one. This\n     * prevents a signature from being used multiple times.\n     */\n    function nonces(address owner) external view returns (uint256);\n\n    /**\n     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n"}},"language":"Solidity","settings":{"metadata":{"bytecodeHash":"ipfs"},"libraries":{},"optimizer":{"runs":800,"enabled":true},"evmVersion":"istanbul","remappings":[]}},"stdJsonOutput":{"sources":{"src/libs/BytesLib.sol":{"id":5},"src/MayanForwarder.sol":{"id":4},"@openzeppelin/contracts/utils/Address.sol":{"id":3},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"id":0},"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol":{"id":2},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol":{"id":1}},"contracts":{"src/MayanForwarder.sol":{"MayanForwarder2":{"abi":[{"type":"constructor","inputs":[{"name":"_guardian","type":"address","internalType":"address"},{"name":"_swapProtocols","type":"address[]","internalType":"address[]"},{"name":"_mayanProtocols","type":"address[]","internalType":"address[]"}],"stateMutability":"nonpayable"},{"name":"UnsupportedProtocol","type":"error","inputs":[]},{"name":"ForwardedERC20","type":"event","inputs":[{"name":"token","type":"address","indexed":false,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"mayanProtocol","type":"address","indexed":false,"internalType":"address"},{"name":"protocolData","type":"bytes","indexed":false,"internalType":"bytes"}],"anonymous":false},{"name":"ForwardedEth","type":"event","inputs":[{"name":"mayanProtocol","type":"address","indexed":false,"internalType":"address"},{"name":"protocolData","type":"bytes","indexed":false,"internalType":"bytes"}],"anonymous":false},{"name":"SwapAndForwarded","type":"event","inputs":[{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"SwapAndForwardedERC20","type":"event","inputs":[{"name":"tokenIn","type":"address","indexed":false,"internalType":"address"},{"name":"amountIn","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"swapProtocol","type":"address","indexed":false,"internalType":"address"},{"name":"middleToken","type":"address","indexed":false,"internalType":"address"},{"name":"middleAmount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"mayanProtocol","type":"address","indexed":false,"internalType":"address"},{"name":"mayanData","type":"bytes","indexed":false,"internalType":"bytes"}],"anonymous":false},{"name":"SwapAndForwardedEth","type":"event","inputs":[{"name":"amountIn","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"swapProtocol","type":"address","indexed":false,"internalType":"address"},{"name":"middleToken","type":"address","indexed":false,"internalType":"address"},{"name":"middleAmount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"mayanProtocol","type":"address","indexed":false,"internalType":"address"},{"name":"mayanData","type":"bytes","indexed":false,"internalType":"bytes"}],"anonymous":false},{"name":"changeGuardian","type":"function","inputs":[{"name":"newGuardian","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"claimGuardian","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"forwardERC20","type":"function","inputs":[{"name":"tokenIn","type":"address","internalType":"address"},{"name":"amountIn","type":"uint256","internalType":"uint256"},{"name":"permitParams","type":"tuple","components":[{"name":"value","type":"uint256","internalType":"uint256"},{"name":"deadline","type":"uint256","internalType":"uint256"},{"name":"v","type":"uint8","internalType":"uint8"},{"name":"r","type":"bytes32","internalType":"bytes32"},{"name":"s","type":"bytes32","internalType":"bytes32"}],"internalType":"struct MayanForwarder2.PermitParams"},{"name":"mayanProtocol","type":"address","internalType":"address"},{"name":"protocolData","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"payable"},{"name":"forwardEth","type":"function","inputs":[{"name":"mayanProtocol","type":"address","internalType":"address"},{"name":"protocolData","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"payable"},{"name":"guardian","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"mayanProtocols","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"nextGuardian","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"rescueEth","type":"function","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"to","type":"address","internalType":"address payable"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"rescueToken","type":"function","inputs":[{"name":"token","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"to","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setMayanProtocol","type":"function","inputs":[{"name":"mayanProtocol","type":"address","internalType":"address"},{"name":"enabled","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setSwapProtocol","type":"function","inputs":[{"name":"swapProtocol","type":"address","internalType":"address"},{"name":"enabled","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"swapAndForwardERC20","type":"function","inputs":[{"name":"tokenIn","type":"address","internalType":"address"},{"name":"amountIn","type":"uint256","internalType":"uint256"},{"name":"permitParams","type":"tuple","components":[{"name":"value","type":"uint256","internalType":"uint256"},{"name":"deadline","type":"uint256","internalType":"uint256"},{"name":"v","type":"uint8","internalType":"uint8"},{"name":"r","type":"bytes32","internalType":"bytes32"},{"name":"s","type":"bytes32","internalType":"bytes32"}],"internalType":"struct MayanForwarder2.PermitParams"},{"name":"swapProtocol","type":"address","internalType":"address"},{"name":"swapData","type":"bytes","internalType":"bytes"},{"name":"middleToken","type":"address","internalType":"address"},{"name":"minMiddleAmount","type":"uint256","internalType":"uint256"},{"name":"mayanProtocol","type":"address","internalType":"address"},{"name":"mayanData","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"payable"},{"name":"swapAndForwardEth","type":"function","inputs":[{"name":"amountIn","type":"uint256","internalType":"uint256"},{"name":"swapProtocol","type":"address","internalType":"address"},{"name":"swapData","type":"bytes","internalType":"bytes"},{"name":"middleToken","type":"address","internalType":"address"},{"name":"minMiddleAmount","type":"uint256","internalType":"uint256"},{"name":"mayanProtocol","type":"address","internalType":"address"},{"name":"mayanData","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"payable"},{"name":"swapProtocols","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"type":"receive","stateMutability":"payable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.4+commit.c7e474f2\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_guardian\",\"type\":\"address\"},{\"internalType\":\"address[]\",\"name\":\"_swapProtocols\",\"type\":\"address[]\"},{\"internalType\":\"address[]\",\"name\":\"_mayanProtocols\",\"type\":\"address[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"UnsupportedProtocol\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"mayanProtocol\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"protocolData\",\"type\":\"bytes\"}],\"name\":\"ForwardedERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"mayanProtocol\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"protocolData\",\"type\":\"bytes\"}],\"name\":\"ForwardedEth\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"SwapAndForwarded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"tokenIn\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"swapProtocol\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"middleToken\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"middleAmount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"mayanProtocol\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"mayanData\",\"type\":\"bytes\"}],\"name\":\"SwapAndForwardedERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"swapProtocol\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"middleToken\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"middleAmount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"mayanProtocol\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"mayanData\",\"type\":\"bytes\"}],\"name\":\"SwapAndForwardedEth\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newGuardian\",\"type\":\"address\"}],\"name\":\"changeGuardian\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"claimGuardian\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenIn\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"internalType\":\"struct MayanForwarder2.PermitParams\",\"name\":\"permitParams\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"mayanProtocol\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"protocolData\",\"type\":\"bytes\"}],\"name\":\"forwardERC20\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"mayanProtocol\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"protocolData\",\"type\":\"bytes\"}],\"name\":\"forwardEth\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"guardian\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"mayanProtocols\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"nextGuardian\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address payable\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"rescueEth\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"rescueToken\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"mayanProtocol\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"enabled\",\"type\":\"bool\"}],\"name\":\"setMayanProtocol\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"swapProtocol\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"enabled\",\"type\":\"bool\"}],\"name\":\"setSwapProtocol\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenIn\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"internalType\":\"struct MayanForwarder2.PermitParams\",\"name\":\"permitParams\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"swapProtocol\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"swapData\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"middleToken\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"minMiddleAmount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"mayanProtocol\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"mayanData\",\"type\":\"bytes\"}],\"name\":\"swapAndForwardERC20\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"swapProtocol\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"swapData\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"middleToken\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"minMiddleAmount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"mayanProtocol\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"mayanData\",\"type\":\"bytes\"}],\"name\":\"swapAndForwardEth\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"swapProtocols\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/MayanForwarder.sol\":\"MayanForwarder2\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":800},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"keccak256\":\"0x287b55befed2961a7eabd7d7b1b2839cbca8a5b80ef8dcbb25ed3d4c2002c305\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://bd39944e8fc06be6dbe2dd1d8449b5336e23c6a7ba3e8e9ae5ae0f37f35283f5\",\"dweb:/ipfs/QmPV3FGYjVwvKSgAXKUN3r9T9GwniZz83CxBpM7vyj2G53\"]},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol\":{\"keccak256\":\"0xec63854014a5b4f2b3290ab9103a21bdf902a508d0f41a8573fea49e98bf571a\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://bc5b5dc12fbc4002f282eaa7a5f06d8310ed62c1c77c5770f6283e058454c39a\",\"dweb:/ipfs/Qme9rE2wS3yBuyJq9GgbmzbsBQsW2M2sVFqYYLw7bosGrv\"]},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"keccak256\":\"0xabefac93435967b4d36a4fabcbdbb918d1f0b7ae3c3d85bc30923b326c927ed1\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://9d213d3befca47da33f6db0310826bcdb148299805c10d77175ecfe1d06a9a68\",\"dweb:/ipfs/QmRgCn6SP1hbBkExUADFuDo8xkT4UU47yjNF5FhCeRbQmS\"]},\"@openzeppelin/contracts/utils/Address.sol\":{\"keccak256\":\"0x006dd67219697fe68d7fbfdea512e7c4cb64a43565ed86171d67e844982da6fa\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://2455248c8ddd9cc6a7af76a13973cddf222072427e7b0e2a7d1aff345145e931\",\"dweb:/ipfs/QmfYjnjRbWqYpuxurqveE6HtzsY1Xx323J428AKQgtBJZm\"]},\"src/MayanForwarder.sol\":{\"keccak256\":\"0x85fb48683079499922a20d1259ac853f674c3c844c61c9082e296b94260f196a\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://9cfc40f8b6dff01ced03f40468cfca348be7aaa2b798981503a07392dabf52ea\",\"dweb:/ipfs/QmTPd9QxMSXQ2EsvAYQPFye2Pw6JTgkDFT2pWHwTaNiH2v\"]},\"src/libs/BytesLib.sol\":{\"keccak256\":\"0xf75784dfc94ea43668eb195d5690a1dde1b6eda62017e73a3899721583821d29\",\"license\":\"Unlicense\",\"urls\":[\"bzz-raw://ca16cef8b94f3ac75d376489a668618f6c4595a906b939d674a883f4bf426014\",\"dweb:/ipfs/QmceGU7qhyFLSejaj6i4dEtMzXDCSF3aYDtW1UeKjXQaRn\"]}},\"version\":1}","userdoc":{"kind":"user","methods":{},"version":1},"devdoc":{"kind":"dev","methods":{},"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":838,"label":"guardian","offset":0,"contract":"src/MayanForwarder.sol:MayanForwarder2"},{"slot":"1","type":"t_address","astId":840,"label":"nextGuardian","offset":0,"contract":"src/MayanForwarder.sol:MayanForwarder2"},{"slot":"2","type":"t_mapping(t_address,t_bool)","astId":844,"label":"swapProtocols","offset":0,"contract":"src/MayanForwarder.sol:MayanForwarder2"},{"slot":"3","type":"t_mapping(t_address,t_bool)","astId":848,"label":"mayanProtocols","offset":0,"contract":"src/MayanForwarder.sol:MayanForwarder2"}]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"287:8141:4:-:0;;;1184:337;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1286:8;:20;;-1:-1:-1;;;;;;1286:20:4;-1:-1:-1;;;;;1286:20:4;;;;;1310:101;1334:14;:21;1330:1;:25;1310:101;;;1402:4;1367:13;:32;1381:14;1396:1;1381:17;;;;;;-1:-1:-1;;;1381:17:4;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1367:32:4;;;;;;;;;;;-1:-1:-1;1367:32:4;:39;;-1:-1:-1;;1367:39:4;;;;;;;;;;1357:3;;;;:::i;:::-;;;;1310:101;;;;1419:9;1414:104;1438:15;:22;1434:1;:26;1414:104;;;1509:4;1472:14;:34;1487:15;1503:1;1487:18;;;;;;-1:-1:-1;;;1487:18:4;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1472:34:4;;;;;;;;;;;-1:-1:-1;1472:34:4;:41;;-1:-1:-1;;1472:41:4;;;;;;;;;;1462:3;;;;:::i;:::-;;;;1414:104;;;;1184:337;;;287:8141;;14:177:6;93:13;;-1:-1:-1;;;;;135:31:6;;125:42;;115:2;;181:1;178;171:12;115:2;74:117;;;:::o;196:954::-;261:5;314:3;307:4;299:6;295:17;291:27;281:2;;336:5;329;322:20;281:2;363:13;;395:4;-1:-1:-1;;;;;448:10:6;;;445:2;;;461:18;;:::i;:::-;507:2;504:1;500:10;539:2;533:9;602:2;598:7;593:2;589;585:11;581:25;573:6;569:38;657:6;645:10;642:22;637:2;625:10;622:18;619:46;616:2;;;668:18;;:::i;:::-;704:2;697:22;754:18;;;788:15;;;;-1:-1:-1;823:15:6;;;857;;;853:24;;850:33;-1:-1:-1;847:2:6;;;900:5;893;886:20;847:2;926:5;917:14;;940:180;954:2;951:1;948:9;940:180;;;1011:34;1041:3;1011:34;:::i;:::-;999:47;;1066:12;;;;972:1;965:9;;;;;1098:12;;940:180;;;-1:-1:-1;1138:6:6;271:879;-1:-1:-1;;;;;;;271:879:6:o;1155:729::-;1293:6;1301;1309;1362:2;1350:9;1341:7;1337:23;1333:32;1330:2;;;1383:6;1375;1368:22;1330:2;1411:40;1441:9;1411:40;:::i;:::-;1495:2;1480:18;;1474:25;1401:50;;-1:-1:-1;;;;;;1548:14:6;;;1545:2;;;1580:6;1572;1565:22;1545:2;1608:72;1672:7;1663:6;1652:9;1648:22;1608:72;:::i;:::-;1598:82;;1726:2;1715:9;1711:18;1705:25;1689:41;;1755:2;1745:8;1742:16;1739:2;;;1776:6;1768;1761:22;1739:2;;1804:74;1870:7;1859:8;1848:9;1844:24;1804:74;:::i;:::-;1794:84;;;1320:564;;;;;:::o;1889:236::-;1928:3;-1:-1:-1;;1949:17:6;;1946:2;;;-1:-1:-1;;;1989:33:6;;2045:4;2042:1;2035:15;2075:4;1996:3;2063:17;1946:2;-1:-1:-1;2117:1:6;2106:13;;1936:189::o;2130:127::-;2191:10;2186:3;2182:20;2179:1;2172:31;2222:4;2219:1;2212:15;2246:4;2243:1;2236:15;2162:95;287:8141:4;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"287:8141:4:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7789:138;;;;;;;;;;-1:-1:-1;7789:138:4;;;;;:::i;:::-;;:::i;:::-;;3621:1707;;;;;;:::i;:::-;;:::i;415:23::-;;;;;;;;;;-1:-1:-1;415:23:4;;;;-1:-1:-1;;;;;415:23:4;;;;;;-1:-1:-1;;;;;8360:55:6;;;8342:74;;8330:2;8315:18;415:23:4;;;;;;;;7930:124;;;;;;;;;;;;;:::i;441:27::-;;;;;;;;;;-1:-1:-1;441:27:4;;;;-1:-1:-1;;;;;441:27:4;;;8057:165;;;;;;;;;;-1:-1:-1;8057:165:4;;;;;:::i;:::-;;:::i;8225:169::-;;;;;;;;;;-1:-1:-1;8225:169:4;;;;;:::i;:::-;;:::i;519:46::-;;;;;;;;;;-1:-1:-1;519:46:4;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;12016:14:6;;12009:22;11991:41;;11979:2;11964:18;519:46:4;11946:92:6;1524:351:4;;;;;;:::i;:::-;;:::i;7511:275::-;;;;;;;;;;-1:-1:-1;7511:275:4;;;;;:::i;:::-;;:::i;1879:558::-;;;;;;:::i;:::-;;:::i;7339:169::-;;;;;;;;;;-1:-1:-1;7339:169:4;;;;;:::i;:::-;;:::i;2440:1178::-;;;;;;:::i;:::-;;:::i;471:45::-;;;;;;;;;;-1:-1:-1;471:45:4;;;;;:::i;:::-;;;;;;;;;;;;;;;;7789:138;7867:8;;-1:-1:-1;;;;;7867:8:4;7853:10;:22;7845:48;;;;-1:-1:-1;;;7845:48:4;;13751:2:6;7845:48:4;;;13733:21:6;13790:2;13770:18;;;13763:30;-1:-1:-1;;;13809:18:6;;;13802:43;13862:18;;7845:48:4;;;;;;;;;7897:12;:26;;-1:-1:-1;;7897:26:4;-1:-1:-1;;;;;7897:26:4;;;;;;;;;;7789:138::o;3621:1707::-;-1:-1:-1;;;;;3910:27:4;;;;;;:13;:27;;;;;;;;3909:28;;:62;;-1:-1:-1;;;;;;3942:29:4;;;;;;:14;:29;;;;;;;;3941:30;3909:62;3905:106;;;3985:21;;-1:-1:-1;;;3985:21:4;;;;;;;;;;;3905:106;4033:11;-1:-1:-1;;;;;4022:22:4;:7;-1:-1:-1;;;;;4022:22:4;;;4014:73;;;;-1:-1:-1;;;4014:73:4;;18131:2:6;4014:73:4;;;18113:21:6;18170:2;18150:18;;;18143:30;18209:34;18189:18;;;18182:62;18280:8;18260:18;;;18253:36;18306:19;;4014:73:4;18103:228:6;4014:73:4;4114:40;;-1:-1:-1;;;4114:40:4;;4148:4;4114:40;;;8342:74:6;4091:20:4;;-1:-1:-1;;;;;4114:25:4;;;;;8315:18:6;;4114:40:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4091:63;;4158:44;4170:7;4179:8;4189:12;4158:11;:44::i;:::-;4207:20;-1:-1:-1;;;;;4235:25:4;;;4231:152;;4282:44;;-1:-1:-1;;;4282:44:4;;4320:4;4282:44;;;8342:74:6;-1:-1:-1;;;;;4282:29:4;;;;;8315:18:6;;4282:44:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4267:59;;4231:152;;;-1:-1:-1;4357:21:4;4231:152;4387:51;4406:7;4415:12;4429:8;4387:18;:51::i;:::-;4443:12;4461;-1:-1:-1;;;;;4461:17:4;4486:1;4489:8;;4461:37;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4442:56;;;4510:7;4502:45;;;;-1:-1:-1;;;4502:45:4;;17777:2:6;4502:45:4;;;17759:21:6;17816:2;17796:18;;;17789:30;17855:27;17835:18;;;17828:55;17900:18;;4502:45:4;17749:175:6;4502:45:4;-1:-1:-1;;;;;4556:25:4;;;4552:182;;4603:44;;-1:-1:-1;;;4603:44:4;;4641:4;4603:44;;;8342:74:6;4650:12:4;;-1:-1:-1;;;;;4603:29:4;;;;;8315:18:6;;4603:44:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:59;;;;:::i;:::-;4588:74;;4552:182;;;4693:36;4717:12;4693:21;:36;:::i;:::-;4678:51;;4552:182;4761:15;4745:12;:31;;4737:69;;;;-1:-1:-1;;;4737:69:4;;12633:2:6;4737:69:4;;;12615:21:6;12672:2;12652:18;;;12645:30;12711:27;12691:18;;;12684:55;12756:18;;4737:69:4;12605:175:6;4737:69:4;4825:9;-1:-1:-1;;;;;4842:25:4;;4838:136;;4874:19;4881:12;4874:19;;:::i;:::-;;;4838:136;;;4909:60;4928:11;4941:13;4956:12;4909:18;:60::i;:::-;-1:-1:-1;;;;;4992:18:4;;;;5018:3;;5023:25;;;:84;;5063:44;5083:9;;5094:12;5063:19;:44::i;:::-;5023:84;;;5051:9;;5023:84;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;5023:84:4;4992:116;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4978:130;;;;;5120:7;5112:46;;;;-1:-1:-1;;;5112:46:4;;15132:2:6;5112:46:4;;;15114:21:6;15171:2;15151:18;;;15144:30;15210:28;15190:18;;;15183:56;15256:18;;5112:46:4;15104:176:6;5112:46:4;5163:44;5185:7;5194:12;5163:21;:44::i;:::-;5217:107;5239:7;5248:8;5258:12;5272:11;5285:12;5299:13;5314:9;;5217:107;;;;;;;;;;;;;:::i;:::-;;;;;;;;3621:1707;;;;;;;;;;;;;;;:::o;7930:124::-;7988:12;;-1:-1:-1;;;;;7988:12:4;7974:10;:26;7966:57;;;;-1:-1:-1;;;7966:57:4;;14093:2:6;7966:57:4;;;14075:21:6;14132:2;14112:18;;;14105:30;14171:20;14151:18;;;14144:48;14209:18;;7966:57:4;14065:168:6;7966:57:4;8038:12;;;8027:23;;-1:-1:-1;;8027:23:4;-1:-1:-1;;;;;8038:12:4;;;8027:23;;;;;;7930:124::o;8057:165::-;8151:8;;-1:-1:-1;;;;;8151:8:4;8137:10;:22;8129:48;;;;-1:-1:-1;;;8129:48:4;;13751:2:6;8129:48:4;;;13733:21:6;13790:2;13770:18;;;13763:30;-1:-1:-1;;;13809:18:6;;;13802:43;13862:18;;8129:48:4;13723:163:6;8129:48:4;-1:-1:-1;;;;;8181:27:4;;;;;;;;:13;:27;;;;;:37;;-1:-1:-1;;8181:37:4;;;;;;;;;;8057:165::o;8225:169::-;8321:8;;-1:-1:-1;;;;;8321:8:4;8307:10;:22;8299:48;;;;-1:-1:-1;;;8299:48:4;;13751:2:6;8299:48:4;;;13733:21:6;13790:2;13770:18;;;13763:30;-1:-1:-1;;;13809:18:6;;;13802:43;13862:18;;8299:48:4;13723:163:6;8299:48:4;-1:-1:-1;;;;;8351:29:4;;;;;;;;:14;:29;;;;;:39;;-1:-1:-1;;8351:39:4;;;;;;;;;;8225:169::o;1524:351::-;-1:-1:-1;;;;;1629:29:4;;;;;;:14;:29;;;;;;;;1624:74;;1672:21;;-1:-1:-1;;;1672:21:4;;;;;;;;;;;1624:74;1702:12;1720:13;-1:-1:-1;;;;;1720:18:4;1746:9;1757:12;;1720:50;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1701:69;;;1782:7;1774:46;;;;-1:-1:-1;;;1774:46:4;;15132:2:6;1774:46:4;;;15114:21:6;15171:2;15151:18;;;15144:30;15210:28;15190:18;;;15183:56;15256:18;;1774:46:4;15104:176:6;1774:46:4;1830:41;1843:13;1858:12;;1830:41;;;;;;;;:::i;:::-;;;;;;;;1524:351;;;;:::o;7511:275::-;7599:8;;-1:-1:-1;;;;;7599:8:4;7585:10;:22;7577:48;;;;-1:-1:-1;;;7577:48:4;;13751:2:6;7577:48:4;;;13733:21:6;13790:2;13770:18;;;13763:30;-1:-1:-1;;;13809:18:6;;;13802:43;13862:18;;7577:48:4;13723:163:6;7577:48:4;-1:-1:-1;;;;;7637:16:4;;7629:57;;;;-1:-1:-1;;;7629:57:4;;12987:2:6;7629:57:4;;;12969:21:6;13026:2;13006:18;;;12999:30;13065;13045:18;;;13038:58;13113:18;;7629:57:4;12959:178:6;7629:57:4;7691:12;7717:2;-1:-1:-1;;;;;7709:16:4;7733:6;7709:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7690:54;;;7756:7;7748:34;;;;-1:-1:-1;;;7748:34:4;;14440:2:6;7748:34:4;;;14422:21:6;14479:2;14459:18;;;14452:30;14518:16;14498:18;;;14491:44;14552:18;;7748:34:4;14412:164:6;7748:34:4;7511:275;;;:::o;1879:558::-;-1:-1:-1;;;;;2064:29:4;;;;;;:14;:29;;;;;;;;2059:74;;2107:21;;-1:-1:-1;;;2107:21:4;;;;;;;;;;;2059:74;2137:44;2149:7;2158:8;2168:12;2137:11;:44::i;:::-;2186:52;2205:7;2214:13;2229:8;2186:18;:52::i;:::-;2243:12;2261:13;-1:-1:-1;;;;;2261:18:4;2287:9;2298:12;;2261:50;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2242:69;;;2323:7;2315:46;;;;-1:-1:-1;;;2315:46:4;;15132:2:6;2315:46:4;;;15114:21:6;15171:2;15151:18;;;15144:30;15210:28;15190:18;;;15183:56;15256:18;;2315:46:4;15104:176:6;2315:46:4;2371:62;2386:7;2395:8;2405:13;2420:12;;2371:62;;;;;;;;;;:::i;:::-;;;;;;;;1879:558;;;;;;;:::o;7339:169::-;7436:8;;-1:-1:-1;;;;;7436:8:4;7422:10;:22;7414:48;;;;-1:-1:-1;;;7414:48:4;;13751:2:6;7414:48:4;;;13733:21:6;13790:2;13770:18;;;13763:30;-1:-1:-1;;;13809:18:6;;;13802:43;13862:18;;7414:48:4;13723:163:6;7414:48:4;7466:38;-1:-1:-1;;;;;7466:26:4;;7493:2;7497:6;7466:26;:38::i;2440:1178::-;-1:-1:-1;;;;;2670:27:4;;;;;;:13;:27;;;;;;;;2669:28;;:62;;-1:-1:-1;;;;;;2702:29:4;;;;;;:14;:29;;;;;;;;2701:30;2669:62;2665:106;;;2745:21;;-1:-1:-1;;;2745:21:4;;;;;;;;;;;2665:106;-1:-1:-1;;;;;2782:25:4;;2774:72;;;;-1:-1:-1;;;2774:72:4;;15487:2:6;2774:72:4;;;15469:21:6;15526:2;15506:18;;;15499:30;15565:34;15545:18;;;15538:62;-1:-1:-1;;;15616:18:6;;;15609:32;15658:19;;2774:72:4;15459:224:6;2774:72:4;2872:8;2859:9;:21;;2851:55;;;;-1:-1:-1;;;2851:55:4;;17004:2:6;2851:55:4;;;16986:21:6;17043:2;17023:18;;;17016:30;17082:23;17062:18;;;17055:51;17123:18;;2851:55:4;16976:171:6;2851:55:4;2933:44;;-1:-1:-1;;;2933:44:4;;2971:4;2933:44;;;8342:74:6;2910:20:4;;-1:-1:-1;;;;;2933:29:4;;;;;8315:18:6;;2933:44:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2910:67;;2983:12;3001;-1:-1:-1;;;;;3001:17:4;3026:8;3036;;3001:44;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2982:63;;;3057:7;3049:36;;;;-1:-1:-1;;;3049:36:4;;16248:2:6;3049:36:4;;;16230:21:6;16287:2;16267:18;;;16260:30;16326:18;16306;;;16299:46;16362:18;;3049:36:4;16220:166:6;3049:36:4;3105:44;;-1:-1:-1;;;3105:44:4;;3143:4;3105:44;;;8342:74:6;3152:12:4;;-1:-1:-1;;;;;3105:29:4;;;;;8315:18:6;;3105:44:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:59;;;;:::i;:::-;3090:74;;3192:15;3176:12;:31;;3168:69;;;;-1:-1:-1;;;3168:69:4;;12633:2:6;3168:69:4;;;12615:21:6;12672:2;12652:18;;;12645:30;12711:27;12691:18;;;12684:55;12756:18;;3168:69:4;12605:175:6;3168:69:4;3242:60;3261:11;3274:13;3289:12;3242:18;:60::i;:::-;3307:25;3335:44;3355:9;;3366:12;3335:19;:44::i;:::-;3307:72;-1:-1:-1;;;;;;3397:18:4;;3423:20;3435:8;3423:9;:20;:::i;:::-;3445:12;3397:61;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3383:75;;;;;3470:7;3462:46;;;;-1:-1:-1;;;3462:46:4;;15132:2:6;3462:46:4;;;15114:21:6;15171:2;15151:18;;;15144:30;15210:28;15190:18;;;15183:56;15256:18;;3462:46:4;15104:176:6;3462:46:4;3518:96;3538:8;3548:12;3562:11;3575:12;3589:13;3604:9;;3518:96;;;;;;;;;;;;:::i;:::-;;;;;;;;2440:1178;;;;;;;;;;;;:::o;6736:347::-;6870:52;;-1:-1:-1;;;6870:52:4;;6896:10;6870:52;;;8662:34:6;6916:4:4;8712:18:6;;;8705:43;6850:17:4;;-1:-1:-1;;;;;6870:25:4;;;;;8574:18:6;;6870:52:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;6850:72;;6942:8;6930:9;:20;6926:81;;;6957:45;6968:7;6977:10;6989:12;6957:10;:45::i;:::-;7010:69;-1:-1:-1;;;;;7010:32:4;;7043:10;7063:4;7070:8;7010:32;:69::i;:::-;6736:347;;;;:::o;6131:323::-;6287:39;;-1:-1:-1;;;6287:39:4;;6311:4;6287:39;;;8662:34:6;-1:-1:-1;;;;;8732:15:6;;;8712:18;;;8705:43;6246:9:4;;6224:12;;6287:15;;;;;8574:18:6;;6287:39:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;6260:66;;6354:6;6335:16;:25;6331:120;;;6367:29;-1:-1:-1;;;;;6367:17:4;;6385:7;6394:1;6367:17;:29::i;:::-;6401:45;-1:-1:-1;;;;;6401:17:4;;6419:7;-1:-1:-1;;6401:17:4;:45::i;:::-;6131:323;;;;;:::o;5331:797::-;5430:12;5476:2;5456:22;;;5448:55;;;;-1:-1:-1;;;5448:55:4;;14783:2:6;5448:55:4;;;14765:21:6;14822:2;14802:18;;;14795:30;14861:22;14841:18;;;14834:50;14901:18;;5448:55:4;14755:170:6;5448:55:4;5507:25;5545:9;5535:27;;;;;;-1:-1:-1;;;5535:27:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;5535:27:4;;5507:55;;5617:6;5612:70;5633:2;5629:1;:6;5612:70;;;5665:9;;5675:1;5665:12;;;;;-1:-1:-1;;;5665:12:4;;;;;;;;;;;;;;;;;5647;5660:1;5647:15;;;;;;-1:-1:-1;;;5647:15:4;;;;;;;;;;;;:30;-1:-1:-1;;;;;5647:30:4;;;;;;;;-1:-1:-1;5637:3:4;;;;:::i;:::-;;;;5612:70;;;;5811:26;5851:12;5840:24;;;;;;18482:25:6;;18470:2;18455:18;;18437:76;5840:24:4;;;;;;;;;;;;;5811:53;;5873:6;5868:79;5889:2;5885:1;:6;5868:79;;;5926:13;5940:1;5926:16;;;;;;-1:-1:-1;;;5926:16:4;;;;;;;;;;;;;;;5903:12;5916:6;:1;5920:2;5916:6;:::i;:::-;5903:20;;;;;;-1:-1:-1;;;5903:20:4;;;;;;;;;;;;:39;-1:-1:-1;;;;;5903:39:4;;;;;;;;-1:-1:-1;5893:3:4;;;;:::i;:::-;;;;5868:79;;;-1:-1:-1;6030:2:4;6016:85;6034:20;;;6016:85;;;6084:9;;6094:1;6084:12;;;;;-1:-1:-1;;;6084:12:4;;;;;;;;;;;;;;;;;6066;6079:1;6066:15;;;;;;-1:-1:-1;;;6066:15:4;;;;;;;;;;;;:30;-1:-1:-1;;;;;6066:30:4;;;;;;;;-1:-1:-1;6056:3:4;;;;:::i;:::-;;;;6016:85;;;-1:-1:-1;6112:12:4;;5331:797;-1:-1:-1;;;;;5331:797:4:o;7086:250::-;7187:38;;-1:-1:-1;;;7187:38:4;;7219:4;7187:38;;;8342:74:6;7167:17:4;;-1:-1:-1;;;;;7187:23:4;;;;;8315:18:6;;7187:38:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;7167:58;;7245:12;7233:9;:24;7229:104;;;7264:64;7291:10;7303:24;7315:12;7303:9;:24;:::i;:::-;-1:-1:-1;;;;;7264:26:4;;;:64;941:175:2;1050:58;;-1:-1:-1;;;;;10421:55:6;;1050:58:2;;;10403:74:6;10493:18;;;10486:34;;;1023:86:2;;1043:5;;-1:-1:-1;;;1073:23:2;10376:18:6;;1050:58:2;;;;-1:-1:-1;;1050:58:2;;;;;;;;;;;;;;;;;;;;;;;;;;;1023:19;:86::i;6457:276:4:-;-1:-1:-1;;;;;6565:26:4;;;6596:5;6614:4;6624:18;;6647:21;;;;6673:14;;;;;;;;:::i;:::-;6565:164;;;;;;;;;;-1:-1:-1;;;;;9552:15:6;;;6565:164:4;;;9534:34:6;9604:15;;;;9584:18;;;9577:43;9636:18;;;9629:34;;;;9679:18;;;9672:34;9755:4;9743:17;9722:19;;;9715:46;6692:14:4;;;;9777:19:6;;;9770:35;6711:14:4;;;;9821:19:6;;;9814:35;9445:19;;6565:164:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6457:276;;;:::o;1355:203:2:-;1482:68;;-1:-1:-1;;;;;9040:15:6;;;1482:68:2;;;9022:34:6;9092:15;;9072:18;;;9065:43;9124:18;;;9117:34;;;1455:96:2;;1475:5;;-1:-1:-1;;;1505:27:2;8934:18:6;;1482:68:2;8916:241:6;1818:573:2;2143:10;;;2142:62;;-1:-1:-1;2159:39:2;;-1:-1:-1;;;2159:39:2;;2183:4;2159:39;;;8662:34:6;-1:-1:-1;;;;;8732:15:6;;;8712:18;;;8705:43;2159:15:2;;;;;8574:18:6;;2159:39:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;2142:62;2121:163;;;;-1:-1:-1;;;2121:163:2;;17354:2:6;2121:163:2;;;17336:21:6;17393:2;17373:18;;;17366:30;17432:34;17412:18;;;17405:62;17503:24;17483:18;;;17476:52;17545:19;;2121:163:2;17326:244:6;2121:163:2;2321:62;;-1:-1:-1;;;;;10421:55:6;;2321:62:2;;;10403:74:6;10493:18;;;10486:34;;;2294:90:2;;2314:5;;-1:-1:-1;;;2344:22:2;10376:18:6;;2321:62:2;10358:168:6;5196:642:2;5615:23;5641:69;5669:4;5641:69;;;;;;;;;;;;;;;;;5649:5;-1:-1:-1;;;;;5641:27:2;;;:69;;;;;:::i;:::-;5615:95;;5728:10;:17;5749:1;5728:22;:56;;;;5765:10;5754:30;;;;;;;;;;;;:::i;:::-;5720:111;;;;-1:-1:-1;;;5720:111:2;;16593:2:6;5720:111:2;;;16575:21:6;16632:2;16612:18;;;16605:30;16671:34;16651:18;;;16644:62;16742:12;16722:18;;;16715:40;16772:19;;5720:111:2;16565:232:6;4108:223:3;4241:12;4272:52;4294:6;4302:4;4308:1;4311:12;4272:21;:52::i;:::-;4265:59;4108:223;-1:-1:-1;;;;4108:223:3:o;5165:446::-;5330:12;5387:5;5362:21;:30;;5354:81;;;;-1:-1:-1;;;5354:81:3;;13344:2:6;5354:81:3;;;13326:21:6;13383:2;13363:18;;;13356:30;13422:34;13402:18;;;13395:62;13493:8;13473:18;;;13466:36;13519:19;;5354:81:3;13316:228:6;5354:81:3;5446:12;5460:23;5487:6;-1:-1:-1;;;;;5487:11:3;5506:5;5513:4;5487:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5445:73;;;;5535:69;5562:6;5570:7;5579:10;5591:12;5535:26;:69::i;:::-;5528:76;5165:446;-1:-1:-1;;;;;;;5165:446:3:o;7671:628::-;7851:12;7879:7;7875:418;;;7906:17;;7902:286;;-1:-1:-1;;;;;1702:19:3;;;8113:60;;;;-1:-1:-1;;;8113:60:3;;15890:2:6;8113:60:3;;;15872:21:6;15929:2;15909:18;;;15902:30;15968:31;15948:18;;;15941:59;16017:18;;8113:60:3;15862:179:6;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;9161:133;9331:12;9324:20;;-1:-1:-1;;;9324:20:3;;;;;;;;:::i;14:134:6:-;82:20;;111:31;82:20;111:31;:::i;:::-;63:85;;;:::o;153:375::-;204:8;214:6;268:3;261:4;253:6;249:17;245:27;235:2;;293:8;283;276:26;235:2;-1:-1:-1;323:20:6;;366:18;355:30;;352:2;;;405:8;395;388:26;352:2;449:4;441:6;437:17;425:29;;501:3;494:4;485:6;477;473:19;469:30;466:39;463:2;;;518:1;515;508:12;463:2;225:303;;;;;:::o;533:169::-;598:5;643:3;634:6;629:3;625:16;621:26;618:2;;;664:5;657;650:20;618:2;-1:-1:-1;690:6:6;608:94;-1:-1:-1;608:94:6:o;707:257::-;766:6;819:2;807:9;798:7;794:23;790:32;787:2;;;840:6;832;825:22;787:2;884:9;871:23;903:31;928:5;903:31;:::i;:::-;953:5;777:187;-1:-1:-1;;;777:187:6:o;969:392::-;1034:6;1042;1095:2;1083:9;1074:7;1070:23;1066:32;1063:2;;;1116:6;1108;1101:22;1063:2;1160:9;1147:23;1179:31;1204:5;1179:31;:::i;:::-;1229:5;-1:-1:-1;1286:2:6;1271:18;;1258:32;1299:30;1258:32;1299:30;:::i;:::-;1348:7;1338:17;;;1053:308;;;;;:::o;1366:564::-;1445:6;1453;1461;1514:2;1502:9;1493:7;1489:23;1485:32;1482:2;;;1535:6;1527;1520:22;1482:2;1579:9;1566:23;1598:31;1623:5;1598:31;:::i;:::-;1648:5;-1:-1:-1;1704:2:6;1689:18;;1676:32;1731:18;1720:30;;1717:2;;;1768:6;1760;1753:22;1717:2;1812:58;1862:7;1853:6;1842:9;1838:22;1812:58;:::i;:::-;1472:458;;1889:8;;-1:-1:-1;1786:84:6;;-1:-1:-1;;;;1472:458:6:o;1935:466::-;2012:6;2020;2028;2081:2;2069:9;2060:7;2056:23;2052:32;2049:2;;;2102:6;2094;2087:22;2049:2;2146:9;2133:23;2165:31;2190:5;2165:31;:::i;:::-;2215:5;-1:-1:-1;2267:2:6;2252:18;;2239:32;;-1:-1:-1;2323:2:6;2308:18;;2295:32;2336:33;2295:32;2336:33;:::i;:::-;2388:7;2378:17;;;2039:362;;;;;:::o;2406:911::-;2543:6;2551;2559;2567;2575;2583;2636:3;2624:9;2615:7;2611:23;2607:33;2604:2;;;2658:6;2650;2643:22;2604:2;2702:9;2689:23;2721:31;2746:5;2721:31;:::i;:::-;2771:5;-1:-1:-1;2823:2:6;2808:18;;2795:32;;-1:-1:-1;2846:68:6;2906:7;2901:2;2886:18;;2846:68;:::i;:::-;2836:78;;2966:3;2955:9;2951:19;2938:33;2980;3005:7;2980:33;:::i;:::-;3032:7;-1:-1:-1;3090:3:6;3075:19;;3062:33;3118:18;3107:30;;3104:2;;;3155:6;3147;3140:22;3104:2;3199:58;3249:7;3240:6;3229:9;3225:22;3199:58;:::i;:::-;2594:723;;;;-1:-1:-1;2594:723:6;;-1:-1:-1;2594:723:6;;3276:8;;2594:723;-1:-1:-1;;;2594:723:6:o;3322:1429::-;3506:6;3514;3522;3530;3538;3546;3554;3562;3570;3578;3586:7;3640:3;3628:9;3619:7;3615:23;3611:33;3608:2;;;3662:6;3654;3647:22;3608:2;3680:49;3718:9;3705:23;3680:49;:::i;:::-;3761:9;3748:23;3738:33;;3818:2;3807:9;3803:18;3790:32;3780:42;;3841:68;3901:7;3896:2;3885:9;3881:18;3841:68;:::i;:::-;3831:78;;3918:59;3971:3;3960:9;3956:19;3943:33;3918:59;:::i;:::-;4024:3;4013:9;4009:19;3996:33;3986:43;;4048:18;4116:2;4109:3;4098:9;4094:19;4081:33;4078:41;4075:2;;;4137:6;4129;4122:22;4075:2;4181:85;4258:7;4250:3;4239:9;4235:19;4222:33;4211:9;4207:49;4181:85;:::i;:::-;4285:8;;-1:-1:-1;4312:8:6;-1:-1:-1;4339:39:6;4373:3;4358:19;;4339:39;:::i;:::-;4329:49;;4425:3;4414:9;4410:19;4397:33;4387:43;;4449:39;4483:3;4472:9;4468:19;4449:39;:::i;:::-;4439:49;;4538:2;4531:3;4520:9;4516:19;4503:33;4500:41;4497:2;;;4559:6;4551;4544:22;4497:2;;4604:85;4681:7;4673:3;4662:9;4658:19;4645:33;4634:9;4630:49;4604:85;:::i;:::-;4708:8;4698:18;;4736:9;4725:20;;;;3598:1153;;;;;;;;;;;;;;:::o;4756:255::-;4823:6;4876:2;4864:9;4855:7;4851:23;4847:32;4844:2;;;4897:6;4889;4882:22;4844:2;4934:9;4928:16;4953:28;4975:5;4953:28;:::i;5016:194::-;5086:6;5139:2;5127:9;5118:7;5114:23;5110:32;5107:2;;;5160:6;5152;5145:22;5107:2;-1:-1:-1;5188:16:6;;5097:113;-1:-1:-1;5097:113:6:o;5215:333::-;5291:6;5299;5352:2;5340:9;5331:7;5327:23;5323:32;5320:2;;;5373:6;5365;5358:22;5320:2;5414:9;5401:23;5391:33;;5474:2;5463:9;5459:18;5446:32;5487:31;5512:5;5487:31;:::i;5553:1304::-;5688:6;5696;5704;5712;5720;5728;5736;5744;5752;5805:3;5793:9;5784:7;5780:23;5776:33;5773:2;;;5827:6;5819;5812:22;5773:2;5868:9;5855:23;5845:33;;5928:2;5917:9;5913:18;5900:32;5941:31;5966:5;5941:31;:::i;:::-;5991:5;-1:-1:-1;6047:2:6;6032:18;;6019:32;6070:18;6100:14;;;6097:2;;;6132:6;6124;6117:22;6097:2;6176:58;6226:7;6217:6;6206:9;6202:22;6176:58;:::i;:::-;6253:8;;-1:-1:-1;6150:84:6;-1:-1:-1;6340:2:6;6325:18;;6312:32;;-1:-1:-1;6353:33:6;6312:32;6353:33;:::i;:::-;6405:7;;-1:-1:-1;6459:3:6;6444:19;;6431:33;;-1:-1:-1;6516:3:6;6501:19;;6488:33;;6530;6488;6530;:::i;:::-;6582:7;;-1:-1:-1;6642:3:6;6627:19;;6614:33;;6659:16;;;6656:2;;;6693:6;6685;6678:22;6656:2;;6737:60;6789:7;6778:8;6767:9;6763:24;6737:60;:::i;:::-;6711:86;;6816:8;6806:18;;;6843:8;6833:18;;;5763:1094;;;;;;;;;;;:::o;6862:289::-;6919:6;6972:2;6960:9;6951:7;6947:23;6943:32;6940:2;;;6993:6;6985;6978:22;6940:2;7037:9;7024:23;7087:4;7080:5;7076:16;7069:5;7066:27;7056:2;;7112:6;7104;7097:22;7156:268;7244:6;7239:3;7232:19;7296:6;7289:5;7282:4;7277:3;7273:14;7260:43;-1:-1:-1;7214:3:6;7323:16;;;7341:4;7319:27;;;7312:40;;;;7406:2;7385:15;;;-1:-1:-1;;7381:29:6;7372:39;;;7368:50;;7222:202::o;7429:273::-;7612:6;7604;7599:3;7586:33;7568:3;7638:16;;7663:15;;;7638:16;7576:126;-1:-1:-1;7576:126:6:o;7707:274::-;7836:3;7874:6;7868:13;7890:53;7936:6;7931:3;7924:4;7916:6;7912:17;7890:53;:::i;:::-;7959:16;;;;;7844:137;-1:-1:-1;;7844:137:6:o;9860:364::-;-1:-1:-1;;;;;10049:6:6;10045:55;10034:9;10027:74;10137:2;10132;10121:9;10117:18;10110:30;10008:4;10157:61;10214:2;10203:9;10199:18;10191:6;10183;10157:61;:::i;:::-;10149:69;10017:207;-1:-1:-1;;;;;10017:207:6:o;10531:772::-;10819:4;-1:-1:-1;;;;;10929:2:6;10921:6;10917:15;10906:9;10899:34;10969:6;10964:2;10953:9;10949:18;10942:34;11024:2;11016:6;11012:15;11007:2;10996:9;10992:18;10985:43;11076:2;11068:6;11064:15;11059:2;11048:9;11044:18;11037:43;11117:6;11111:3;11100:9;11096:19;11089:35;11173:2;11165:6;11161:15;11155:3;11144:9;11140:19;11133:44;;11214:3;11208;11197:9;11193:19;11186:32;11235:62;11292:3;11281:9;11277:19;11269:6;11261;11235:62;:::i;:::-;11227:70;10828:475;-1:-1:-1;;;;;;;;;;10828:475:6:o;11308:538::-;11512:4;-1:-1:-1;;;;;11622:2:6;11614:6;11610:15;11599:9;11592:34;11662:6;11657:2;11646:9;11642:18;11635:34;11717:2;11709:6;11705:15;11700:2;11689:9;11685:18;11678:43;;11757:3;11752:2;11741:9;11737:18;11730:31;11778:62;11835:3;11824:9;11820:19;11812:6;11804;11778:62;:::i;12043:383::-;12192:2;12181:9;12174:21;12155:4;12224:6;12218:13;12267:6;12262:2;12251:9;12247:18;12240:34;12283:66;12342:6;12337:2;12326:9;12322:18;12317:2;12309:6;12305:15;12283:66;:::i;:::-;12410:2;12389:15;-1:-1:-1;;12385:29:6;12370:45;;;;12417:2;12366:54;;12164:262;-1:-1:-1;;12164:262:6:o;18518:691::-;18815:6;18804:9;18797:25;18778:4;-1:-1:-1;;;;;18931:2:6;18923:6;18919:15;18914:2;18903:9;18899:18;18892:43;18983:2;18975:6;18971:15;18966:2;18955:9;18951:18;18944:43;19023:6;19018:2;19007:9;19003:18;18996:34;19079:2;19071:6;19067:15;19061:3;19050:9;19046:19;19039:44;;19120:3;19114;19103:9;19099:19;19092:32;19141:62;19198:3;19187:9;19183:19;19175:6;19167;19141:62;:::i;:::-;19133:70;18787:422;-1:-1:-1;;;;;;;;;18787:422:6:o;19214:128::-;19254:3;19285:1;19281:6;19278:1;19275:13;19272:2;;;19291:18;;:::i;:::-;-1:-1:-1;19327:9:6;;19262:80::o;19347:125::-;19387:4;19415:1;19412;19409:8;19406:2;;;19420:18;;:::i;:::-;-1:-1:-1;19457:9:6;;19396:76::o;19477:258::-;19549:1;19559:113;19573:6;19570:1;19567:13;19559:113;;;19649:11;;;19643:18;19630:11;;;19623:39;19595:2;19588:10;19559:113;;;19690:6;19687:1;19684:13;19681:2;;;-1:-1:-1;;19725:1:6;19707:16;;19700:27;19530:205::o;19740:135::-;19779:3;-1:-1:-1;;19800:17:6;;19797:2;;;19820:18;;:::i;:::-;-1:-1:-1;19867:1:6;19856:13;;19787:88::o;19880:127::-;19941:10;19936:3;19932:20;19929:1;19922:31;19972:4;19969:1;19962:15;19996:4;19993:1;19986:15;20012:154;-1:-1:-1;;;;;20091:5:6;20087:54;20080:5;20077:65;20067:2;;20156:1;20153;20146:12;20067:2;20057:109;:::o;20171:118::-;20257:5;20250:13;20243:21;20236:5;20233:32;20223:2;;20279:1;20276;20269:12","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[{"signature":"changeGuardian(address)","signatureHash4":"0x2fcb4f04","signatureHash32":"0x2fcb4f0425a3d0da6a36eb72c691d299b4cf9e71ae86137f898545059fdd6322"},{"signature":"claimGuardian()","signatureHash4":"0x459656ee","signatureHash32":"0x459656ee80b4f5d43f41c0617c9b6f77daf96bf952aef6f2a2c8c62ab2a3586a"},{"signature":"forwardERC20(address,uint256,(uint256,uint256,uint8,bytes32,bytes32),address,bytes)","signatureHash4":"0xe4269fc4","signatureHash32":"0xe4269fc43f5aee66a39c980fc270721475dca327303e1a0880f6033e5d2b903b"},{"signature":"forwardEth(address,bytes)","signatureHash4":"0xb0f584ff","signatureHash32":"0xb0f584ff3db540e7192d24db77896800e4886b3a0aac18fe5d6fc39f6e64416b"},{"signature":"guardian()","signatureHash4":"0x452a9320","signatureHash32":"0x452a9320be39ba8cdcdf8271470aaf06f7201b0dfd118a158823255036d429fa"},{"signature":"mayanProtocols(address)","signatureHash4":"0xaf56ca03","signatureHash32":"0xaf56ca03326c4cc54a4c68b7609e939bde3fbd057bbe969ea243f7ebbec79252"},{"signature":"nextGuardian()","signatureHash4":"0x4818e84d","signatureHash32":"0x4818e84dd322152e94f672dc1cedc1519974f26d9e51d5eaa89163910b2083de"},{"signature":"rescueEth(uint256,address)","signatureHash4":"0xb25ea8fb","signatureHash32":"0xb25ea8fbb2fdcf94137fcf69826ee5315f76ce11ec85a744025e3e7049a87256"},{"signature":"rescueToken(address,uint256,address)","signatureHash4":"0xf8a67a62","signatureHash32":"0xf8a67a622d878609f97f1950728e5f6ea72a66626484d7d2907d0347fab1760a"},{"signature":"setMayanProtocol(address,bool)","signatureHash4":"0xa44382fe","signatureHash32":"0xa44382fe6473c9eedf3a2cf54cedec14b991551cce38832487976b846d99dd02"},{"signature":"setSwapProtocol(address,bool)","signatureHash4":"0x7fc920eb","signatureHash32":"0x7fc920ebf4a87cb343d6397d37f86a4cbd2ef3e3da7dd33df7b46cceb20790b4"},{"signature":"swapAndForwardERC20(address,uint256,(uint256,uint256,uint8,bytes32,bytes32),address,bytes,address,uint256,address,bytes)","signatureHash4":"0x30dedc57","signatureHash32":"0x30dedc57bb897fac7f06bd737f67bf929193934e3567e84d77355f2c2459ba39"},{"signature":"swapAndForwardEth(uint256,address,bytes,address,uint256,address,bytes)","signatureHash4":"0xfa74fd43","signatureHash32":"0xfa74fd43972f747f05b284ac0981c0853376602ac6d9279c17015270ead0e7e7"},{"signature":"swapProtocols(address)","signatureHash4":"0xffe80541","signatureHash32":"0xffe80541628d500ba0dcfa27164c66b4e454cac98457d0435c9cc0215645e607"}],"event":[{"signature":"ForwardedERC20(address,uint256,address,bytes)","signatureHash4":"0xbf150db6","signatureHash32":"0xbf150db6b4a14b084f7346b4bc300f552ce867afe55be27bce2d6b37e3307cda"},{"signature":"ForwardedEth(address,bytes)","signatureHash4":"0xb8543d21","signatureHash32":"0xb8543d214cab9591941648db8d40126a163bfd0db4a865678320b921e1398043"},{"signature":"SwapAndForwardedERC20(address,uint256,address,address,uint256,address,bytes)","signatureHash4":"0x23278f58","signatureHash32":"0x23278f58875126c795a4072b98b5851fe9b21cea19895b02a6224fefbb1e3298"},{"signature":"SwapAndForwardedEth(uint256,address,address,uint256,address,bytes)","signatureHash4":"0x7cbff921","signatureHash32":"0x7cbff921ae1f3ea71284120d2aabde13587df067f2bb5c831ea6e35d7a9242ac"},{"signature":"SwapAndForwarded(uint256)","signatureHash4":"0xfe4e324d","signatureHash32":"0xfe4e324d6c3c393853951b3712eb58370dd79d26cd12851f51a33161d31f3ee4"}],"error":[{"signature":"UnsupportedProtocol()","signatureHash4":"0x743f26e1","signatureHash32":"0x743f26e12db31e299b41b7dd55bf417f2416074119a7ad9a7afc42b722a359f6"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"1","address":"0x337685fdaB40D39bd02028545a4FfA7D287cC3E2"}