{"matchId":"10800314","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2025-12-12T14:52:58Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"0x60806040523480156200001157600080fd5b50604080518082018252600a8152692132b0ba102a37b5b2b760b11b6020808301918252835180850190945260048452631099585d60e21b9084015281519192916200006091600391620000ef565b50805162000076906004906020840190620000ef565b505050620000936200008d6200009960201b60201c565b6200009d565b620001d2565b3390565b600580546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b828054620000fd9062000195565b90600052602060002090601f0160209004810192826200012157600085556200016c565b82601f106200013c57805160ff19168380011785556200016c565b828001600101855582156200016c579182015b828111156200016c5782518255916020019190600101906200014f565b506200017a9291506200017e565b5090565b5b808211156200017a57600081556001016200017f565b600281046001821680620001aa57607f821691505b60208210811415620001cc57634e487b7160e01b600052602260045260246000fd5b50919050565b610dcc80620001e26000396000f3fe608060405234801561001057600080fd5b50600436106101005760003560e01c806370a0823111610097578063a457c2d711610066578063a457c2d7146101e8578063a9059cbb146101fb578063dd62ed3e1461020e578063f2fde38b1461022157610100565b806370a08231146101b0578063715018a6146101c35780638da5cb5b146101cb57806395d89b41146101e057610100565b8063313ce567116100d3578063313ce5671461016b57806332cb6b0c14610180578063395093511461018857806340c10f191461019b57610100565b806306fdde0314610105578063095ea7b31461012357806318160ddd1461014357806323b872dd14610158575b600080fd5b61010d610234565b60405161011a9190610a19565b60405180910390f35b6101366101313660046109d1565b6102c6565b60405161011a9190610a0e565b61014b6102e3565b60405161011a9190610cff565b610136610166366004610996565b6102e9565b610173610382565b60405161011a9190610d08565b61014b610387565b6101366101963660046109d1565b610397565b6101ae6101a93660046109d1565b6103eb565b005b61014b6101be366004610943565b61047b565b6101ae61049a565b6101d36104e5565b60405161011a91906109fa565b61010d6104f4565b6101366101f63660046109d1565b610503565b6101366102093660046109d1565b61057c565b61014b61021c366004610964565b610590565b6101ae61022f366004610943565b6105bb565b60606003805461024390610d45565b80601f016020809104026020016040519081016040528092919081815260200182805461026f90610d45565b80156102bc5780601f10610291576101008083540402835291602001916102bc565b820191906000526020600020905b81548152906001019060200180831161029f57829003601f168201915b5050505050905090565b60006102da6102d361062c565b8484610630565b50600192915050565b60025490565b60006102f68484846106e4565b6001600160a01b03841660009081526001602052604081208161031761062c565b6001600160a01b03166001600160a01b03168152602001908152602001600020549050828110156103635760405162461bcd60e51b815260040161035a90610b7d565b60405180910390fd5b6103778561036f61062c565b858403610630565b506001949350505050565b601290565b6b033b2e3c9fd0803ce800000081565b60006102da6103a461062c565b8484600160006103b261062c565b6001600160a01b03908116825260208083019390935260409182016000908120918b16815292529020546103e69190610d16565b610630565b6103f361062c565b6001600160a01b03166104046104e5565b6001600160a01b03161461042a5760405162461bcd60e51b815260040161035a90610bc5565b60006104346102e3565b90506b033b2e3c9fd0803ce800000061044d8284610d16565b111561046c57610469816b033b2e3c9fd0803ce8000000610d2e565b91505b610476838361080e565b505050565b6001600160a01b0381166000908152602081905260409020545b919050565b6104a261062c565b6001600160a01b03166104b36104e5565b6001600160a01b0316146104d95760405162461bcd60e51b815260040161035a90610bc5565b6104e360006108da565b565b6005546001600160a01b031690565b60606004805461024390610d45565b6000806001600061051261062c565b6001600160a01b039081168252602080830193909352604091820160009081209188168152925290205490508281101561055e5760405162461bcd60e51b815260040161035a90610c83565b61057261056961062c565b85858403610630565b5060019392505050565b60006102da61058961062c565b84846106e4565b6001600160a01b03918216600090815260016020908152604080832093909416825291909152205490565b6105c361062c565b6001600160a01b03166105d46104e5565b6001600160a01b0316146105fa5760405162461bcd60e51b815260040161035a90610bc5565b6001600160a01b0381166106205760405162461bcd60e51b815260040161035a90610aaf565b610629816108da565b50565b3390565b6001600160a01b0383166106565760405162461bcd60e51b815260040161035a90610c3f565b6001600160a01b03821661067c5760405162461bcd60e51b815260040161035a90610af5565b6001600160a01b0380841660008181526001602090815260408083209487168084529490915290819020849055517f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925906106d7908590610cff565b60405180910390a3505050565b6001600160a01b03831661070a5760405162461bcd60e51b815260040161035a90610bfa565b6001600160a01b0382166107305760405162461bcd60e51b815260040161035a90610a6c565b61073b838383610476565b6001600160a01b038316600090815260208190526040902054818110156107745760405162461bcd60e51b815260040161035a90610b37565b6001600160a01b038085166000908152602081905260408082208585039055918516815290812080548492906107ab908490610d16565b92505081905550826001600160a01b0316846001600160a01b03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef846040516107f59190610cff565b60405180910390a3610808848484610476565b50505050565b6001600160a01b0382166108345760405162461bcd60e51b815260040161035a90610cc8565b61084060008383610476565b80600260008282546108529190610d16565b90915550506001600160a01b0382166000908152602081905260408120805483929061087f908490610d16565b90915550506040516001600160a01b038316906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef906108c2908590610cff565b60405180910390a36108d660008383610476565b5050565b600580546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b80356001600160a01b038116811461049557600080fd5b600060208284031215610954578081fd5b61095d8261092c565b9392505050565b60008060408385031215610976578081fd5b61097f8361092c565b915061098d6020840161092c565b90509250929050565b6000806000606084860312156109aa578081fd5b6109b38461092c565b92506109c16020850161092c565b9150604084013590509250925092565b600080604083850312156109e3578182fd5b6109ec8361092c565b946020939093013593505050565b6001600160a01b0391909116815260200190565b901515815260200190565b6000602080835283518082850152825b81811015610a4557858101830151858201604001528201610a29565b81811115610a565783604083870101525b50601f01601f1916929092016040019392505050565b60208082526023908201527f45524332303a207472616e7366657220746f20746865207a65726f206164647260408201526265737360e81b606082015260800190565b60208082526026908201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160408201526564647265737360d01b606082015260800190565b60208082526022908201527f45524332303a20617070726f766520746f20746865207a65726f206164647265604082015261737360f01b606082015260800190565b60208082526026908201527f45524332303a207472616e7366657220616d6f756e7420657863656564732062604082015265616c616e636560d01b606082015260800190565b60208082526028908201527f45524332303a207472616e7366657220616d6f756e74206578636565647320616040820152676c6c6f77616e636560c01b606082015260800190565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b60208082526025908201527f45524332303a207472616e736665722066726f6d20746865207a65726f206164604082015264647265737360d81b606082015260800190565b60208082526024908201527f45524332303a20617070726f76652066726f6d20746865207a65726f206164646040820152637265737360e01b606082015260800190565b60208082526025908201527f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f77604082015264207a65726f60d81b606082015260800190565b6020808252601f908201527f45524332303a206d696e7420746f20746865207a65726f206164647265737300604082015260600190565b90815260200190565b60ff91909116815260200190565b60008219821115610d2957610d29610d80565b500190565b600082821015610d4057610d40610d80565b500390565b600281046001821680610d5957607f821691505b60208210811415610d7a57634e487b7160e01b600052602260045260246000fd5b50919050565b634e487b7160e01b600052601160045260246000fdfea26469706673582212206894a37776829d033227229cffa8a9ce1310e26a62169619122db6eb7c9ead2764736f6c63430008000033","sourceMap":"152:458:0:-:0;;;286:49;;;;;;;;;-1:-1:-1;1909:113:2;;;;;;;;;;;-1:-1:-1;;;1909:113:2;;;;;;;;;;;;;;;;;;-1:-1:-1;;;1909:113:2;;;;1975:13;;1909:113;;;1975:13;;:5;;:13;:::i;:::-;-1:-1:-1;1998:17:2;;;;:7;;:17;;;;;:::i;:::-;;1909:113;;860:23:3;870:12;:10;;;:12;;:::i;:::-;860:9;:23::i;:::-;152:458:0;;587:96:1;666:10;587:96;:::o;2034:169:3:-;2108:6;;;-1:-1:-1;;;;;2124:17:3;;;-1:-1:-1;;;;;;2124:17:3;;;;;;;2156:40;;2108:6;;;2124:17;2108:6;;2156:40;;2089:16;;2156:40;2034:169;;:::o;152:458:0:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;152:458:0;;;-1:-1:-1;152:458:0;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:380:7;99:1;89:12;;146:1;136:12;;;157:2;;211:4;203:6;199:17;189:27;;157:2;264;256:6;253:14;233:18;230:38;227:2;;;310:10;305:3;301:20;298:1;291:31;345:4;342:1;335:15;373:4;370:1;363:15;227:2;;69:325;;;:::o;:::-;152:458:0;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa26469706673582212206894a37776829d033227229cffa8a9ce1310e26a62169619122db6eb7c9ead2764736f6c63430008000033","offset":3961}},"transformations":[],"transformationValues":{}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"152:458:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2087:98:2;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4184:166;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;3175:106::-;;;:::i;:::-;;;;;;;:::i;4817:478::-;;;;;;:::i;:::-;;:::i;3024:91::-;;;:::i;:::-;;;;;;;:::i;223:56:0:-;;;:::i;5690:212:2:-;;;;;;:::i;:::-;;:::i;341:267:0:-;;;;;;:::i;:::-;;:::i;:::-;;3339:125:2;;;;;;:::i;:::-;;:::i;1598:92:3:-;;;:::i;966:85::-;;;:::i;:::-;;;;;;;:::i;2298:102:2:-;;;:::i;6389:405::-;;;;;;:::i;:::-;;:::i;3667:172::-;;;;;;:::i;:::-;;:::i;3897:149::-;;;;;;:::i;:::-;;:::i;1839:189:3:-;;;;;;:::i;:::-;;:::i;2087:98:2:-;2141:13;2173:5;2166:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2087:98;:::o;4184:166::-;4267:4;4283:39;4292:12;:10;:12::i;:::-;4306:7;4315:6;4283:8;:39::i;:::-;-1:-1:-1;4339:4:2;4184:166;;;;:::o;3175:106::-;3262:12;;3175:106;:::o;4817:478::-;4953:4;4969:36;4979:6;4987:9;4998:6;4969:9;:36::i;:::-;-1:-1:-1;;;;;5043:19:2;;5016:24;5043:19;;;:11;:19;;;;;5016:24;5063:12;:10;:12::i;:::-;-1:-1:-1;;;;;5043:33:2;-1:-1:-1;;;;;5043:33:2;;;;;;;;;;;;;5016:60;;5114:6;5094:16;:26;;5086:79;;;;-1:-1:-1;;;5086:79:2;;;;;;;:::i;:::-;;;;;;;;;5199:57;5208:6;5216:12;:10;:12::i;:::-;5249:6;5230:16;:25;5199:8;:57::i;:::-;-1:-1:-1;5284:4:2;;4817:478;-1:-1:-1;;;;4817:478:2:o;3024:91::-;3106:2;3024:91;:::o;223:56:0:-;260:19;223:56;:::o;5690:212:2:-;5778:4;5794:80;5803:12;:10;:12::i;:::-;5817:7;5863:10;5826:11;:25;5838:12;:10;:12::i;:::-;-1:-1:-1;;;;;5826:25:2;;;;;;;;;;;;;;;;;-1:-1:-1;5826:25:2;;;:34;;;;;;;;;;:47;;;;:::i;:::-;5794:8;:80::i;341:267:0:-;1189:12:3;:10;:12::i;:::-;-1:-1:-1;;;;;1178:23:3;:7;:5;:7::i;:::-;-1:-1:-1;;;;;1178:23:3;;1170:68;;;;-1:-1:-1;;;1170:68:3;;;;;;;:::i;:::-;421:20:0::1;444:13;:11;:13::i;:::-;421:36:::0;-1:-1:-1;260:19:0::1;471:22;421:36:::0;471:7;:22:::1;:::i;:::-;:35;467:101;;;532:25;545:12:::0;260:19:::1;532:25;:::i;:::-;522:35;;467:101;577:24;583:8;593:7;577:5;:24::i;:::-;1248:1:3;341:267:0::0;;:::o;3339:125:2:-;-1:-1:-1;;;;;3439:18:2;;3413:7;3439:18;;;;;;;;;;;3339:125;;;;:::o;1598:92:3:-;1189:12;:10;:12::i;:::-;-1:-1:-1;;;;;1178:23:3;:7;:5;:7::i;:::-;-1:-1:-1;;;;;1178:23:3;;1170:68;;;;-1:-1:-1;;;1170:68:3;;;;;;;:::i;:::-;1662:21:::1;1680:1;1662:9;:21::i;:::-;1598:92::o:0;966:85::-;1038:6;;-1:-1:-1;;;;;1038:6:3;966:85;:::o;2298:102:2:-;2354:13;2386:7;2379:14;;;;;:::i;6389:405::-;6482:4;6498:24;6525:11;:25;6537:12;:10;:12::i;:::-;-1:-1:-1;;;;;6525:25:2;;;;;;;;;;;;;;;;;-1:-1:-1;6525:25:2;;;:34;;;;;;;;;;;-1:-1:-1;6577:35:2;;;;6569:85;;;;-1:-1:-1;;;6569:85:2;;;;;;;:::i;:::-;6688:67;6697:12;:10;:12::i;:::-;6711:7;6739:15;6720:16;:34;6688:8;:67::i;:::-;-1:-1:-1;6783:4:2;;6389:405;-1:-1:-1;;;6389:405:2:o;3667:172::-;3753:4;3769:42;3779:12;:10;:12::i;:::-;3793:9;3804:6;3769:9;:42::i;3897:149::-;-1:-1:-1;;;;;4012:18:2;;;3986:7;4012:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;3897:149::o;1839:189:3:-;1189:12;:10;:12::i;:::-;-1:-1:-1;;;;;1178:23:3;:7;:5;:7::i;:::-;-1:-1:-1;;;;;1178:23:3;;1170:68;;;;-1:-1:-1;;;1170:68:3;;;;;;;:::i;:::-;-1:-1:-1;;;;;1927:22:3;::::1;1919:73;;;;-1:-1:-1::0;;;1919:73:3::1;;;;;;;:::i;:::-;2002:19;2012:8;2002:9;:19::i;:::-;1839:189:::0;:::o;587:96:1:-;666:10;587:96;:::o;9965:370:2:-;-1:-1:-1;;;;;10096:19:2;;10088:68;;;;-1:-1:-1;;;10088:68:2;;;;;;;:::i;:::-;-1:-1:-1;;;;;10174:21:2;;10166:68;;;;-1:-1:-1;;;10166:68:2;;;;;;;:::i;:::-;-1:-1:-1;;;;;10245:18:2;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;;:36;;;10296:32;;;;;10275:6;;10296:32;:::i;:::-;;;;;;;;9965:370;;;:::o;7268:713::-;-1:-1:-1;;;;;7403:20:2;;7395:70;;;;-1:-1:-1;;;7395:70:2;;;;;;;:::i;:::-;-1:-1:-1;;;;;7483:23:2;;7475:71;;;;-1:-1:-1;;;7475:71:2;;;;;;;:::i;:::-;7557:47;7578:6;7586:9;7597:6;7557:20;:47::i;:::-;-1:-1:-1;;;;;7639:17:2;;7615:21;7639:17;;;;;;;;;;;7674:23;;;;7666:74;;;;-1:-1:-1;;;7666:74:2;;;;;;;:::i;:::-;-1:-1:-1;;;;;7774:17:2;;;:9;:17;;;;;;;;;;;7794:22;;;7774:42;;7836:20;;;;;;;;:30;;7810:6;;7774:9;7836:30;;7810:6;;7836:30;:::i;:::-;;;;;;;;7899:9;-1:-1:-1;;;;;7882:35:2;7891:6;-1:-1:-1;;;;;7882:35:2;;7910:6;7882:35;;;;;;:::i;:::-;;;;;;;;7928:46;7948:6;7956:9;7967:6;7928:19;:46::i;:::-;7268:713;;;;:::o;8257:389::-;-1:-1:-1;;;;;8340:21:2;;8332:65;;;;-1:-1:-1;;;8332:65:2;;;;;;;:::i;:::-;8408:49;8437:1;8441:7;8450:6;8408:20;:49::i;:::-;8484:6;8468:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;8500:18:2;;:9;:18;;;;;;;;;;:28;;8522:6;;8500:9;:28;;8522:6;;8500:28;:::i;:::-;;;;-1:-1:-1;;8543:37:2;;-1:-1:-1;;;;;8543:37:2;;;8560:1;;8543:37;;;;8573:6;;8543:37;:::i;:::-;;;;;;;;8591:48;8619:1;8623:7;8632:6;8591:19;:48::i;:::-;8257:389;;:::o;2034:169:3:-;2108:6;;;-1:-1:-1;;;;;2124:17:3;;;-1:-1:-1;;;;;;2124:17:3;;;;;;;2156:40;;2108:6;;;2124:17;2108:6;;2156:40;;2089:16;;2156:40;2034:169;;:::o;14:175:7:-;84:20;;-1:-1:-1;;;;;133:31:7;;123:42;;113:2;;179:1;176;169:12;194:198;;306:2;294:9;285:7;281:23;277:32;274:2;;;327:6;319;312:22;274:2;355:31;376:9;355:31;:::i;:::-;345:41;264:128;-1:-1:-1;;;264:128:7:o;397:274::-;;;526:2;514:9;505:7;501:23;497:32;494:2;;;547:6;539;532:22;494:2;575:31;596:9;575:31;:::i;:::-;565:41;;625:40;661:2;650:9;646:18;625:40;:::i;:::-;615:50;;484:187;;;;;:::o;676:342::-;;;;822:2;810:9;801:7;797:23;793:32;790:2;;;843:6;835;828:22;790:2;871:31;892:9;871:31;:::i;:::-;861:41;;921:40;957:2;946:9;942:18;921:40;:::i;:::-;911:50;;1008:2;997:9;993:18;980:32;970:42;;780:238;;;;;:::o;1023:266::-;;;1152:2;1140:9;1131:7;1127:23;1123:32;1120:2;;;1173:6;1165;1158:22;1120:2;1201:31;1222:9;1201:31;:::i;:::-;1191:41;1279:2;1264:18;;;;1251:32;;-1:-1:-1;;;1110:179:7:o;1294:203::-;-1:-1:-1;;;;;1458:32:7;;;;1440:51;;1428:2;1413:18;;1395:102::o;1502:187::-;1667:14;;1660:22;1642:41;;1630:2;1615:18;;1597:92::o;1694:603::-;;1835:2;1864;1853:9;1846:21;1896:6;1890:13;1939:6;1934:2;1923:9;1919:18;1912:34;1964:4;1977:140;1991:6;1988:1;1985:13;1977:140;;;2086:14;;;2082:23;;2076:30;2052:17;;;2071:2;2048:26;2041:66;2006:10;;1977:140;;;2135:6;2132:1;2129:13;2126:2;;;2205:4;2200:2;2191:6;2180:9;2176:22;2172:31;2165:45;2126:2;-1:-1:-1;2281:2:7;2260:15;-1:-1:-1;;2256:29:7;2241:45;;;;2288:2;2237:54;;1815:482;-1:-1:-1;;;1815:482:7:o;2302:399::-;2504:2;2486:21;;;2543:2;2523:18;;;2516:30;2582:34;2577:2;2562:18;;2555:62;-1:-1:-1;;;2648:2:7;2633:18;;2626:33;2691:3;2676:19;;2476:225::o;2706:402::-;2908:2;2890:21;;;2947:2;2927:18;;;2920:30;2986:34;2981:2;2966:18;;2959:62;-1:-1:-1;;;3052:2:7;3037:18;;3030:36;3098:3;3083:19;;2880:228::o;3113:398::-;3315:2;3297:21;;;3354:2;3334:18;;;3327:30;3393:34;3388:2;3373:18;;3366:62;-1:-1:-1;;;3459:2:7;3444:18;;3437:32;3501:3;3486:19;;3287:224::o;3516:402::-;3718:2;3700:21;;;3757:2;3737:18;;;3730:30;3796:34;3791:2;3776:18;;3769:62;-1:-1:-1;;;3862:2:7;3847:18;;3840:36;3908:3;3893:19;;3690:228::o;3923:404::-;4125:2;4107:21;;;4164:2;4144:18;;;4137:30;4203:34;4198:2;4183:18;;4176:62;-1:-1:-1;;;4269:2:7;4254:18;;4247:38;4317:3;4302:19;;4097:230::o;4332:356::-;4534:2;4516:21;;;4553:18;;;4546:30;4612:34;4607:2;4592:18;;4585:62;4679:2;4664:18;;4506:182::o;4693:401::-;4895:2;4877:21;;;4934:2;4914:18;;;4907:30;4973:34;4968:2;4953:18;;4946:62;-1:-1:-1;;;5039:2:7;5024:18;;5017:35;5084:3;5069:19;;4867:227::o;5099:400::-;5301:2;5283:21;;;5340:2;5320:18;;;5313:30;5379:34;5374:2;5359:18;;5352:62;-1:-1:-1;;;5445:2:7;5430:18;;5423:34;5489:3;5474:19;;5273:226::o;5504:401::-;5706:2;5688:21;;;5745:2;5725:18;;;5718:30;5784:34;5779:2;5764:18;;5757:62;-1:-1:-1;;;5850:2:7;5835:18;;5828:35;5895:3;5880:19;;5678:227::o;5910:355::-;6112:2;6094:21;;;6151:2;6131:18;;;6124:30;6190:33;6185:2;6170:18;;6163:61;6256:2;6241:18;;6084:181::o;6270:177::-;6416:25;;;6404:2;6389:18;;6371:76::o;6452:184::-;6624:4;6612:17;;;;6594:36;;6582:2;6567:18;;6549:87::o;6641:128::-;;6712:1;6708:6;6705:1;6702:13;6699:2;;;6718:18;;:::i;:::-;-1:-1:-1;6754:9:7;;6689:80::o;6774:125::-;;6842:1;6839;6836:8;6833:2;;;6847:18;;:::i;:::-;-1:-1:-1;6884:9:7;;6823:76::o;6904:380::-;6989:1;6979:12;;7036:1;7026:12;;;7047:2;;7101:4;7093:6;7089:17;7079:27;;7047:2;7154;7146:6;7143:14;7123:18;7120:38;7117:2;;;7200:10;7195:3;7191:20;7188:1;7181:31;7235:4;7232:1;7225:15;7263:4;7260:1;7253:15;7117:2;;6959:325;;;:::o;7289:127::-;7350:10;7345:3;7341:20;7338:1;7331:31;7381:4;7378:1;7371:15;7405:4;7402:1;7395:15","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa26469706673582212206894a37776829d033227229cffa8a9ce1310e26a62169619122db6eb7c9ead2764736f6c63430008000033","offset":3479}},"immutableReferences":{},"transformations":[],"transformationValues":{}},"deployment":{"transactionHash":"0xdce1ca20960faf6449b11164753c444092552f887a02080379fe79a79455ca23","blockNumber":"49120649","transactionIndex":"17","deployer":"0x2e2B29D314DB954Ee9d8c5ceD89fA5153a64a04e"},"sources":{"contracts/Beat.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\nimport \"./library/SafeMath.sol\";\nimport \"./helpers/ERC20.sol\";\nimport \"./helpers/Ownable.sol\";\n\ncontract Beat is ERC20, Ownable {\n\n    using SafeMath for uint256;\n    uint256 public constant MAX_SUPPLY = 1000000000 * 10**18;\n\n    constructor() ERC20(\"Beat Token\", \"Beat\") {\n    }\n\n    function mint(address account_, uint256 amount_) external onlyOwner() {\n        uint256 totalSupply_ = totalSupply();\n        if (amount_ + totalSupply_ > MAX_SUPPLY) {\n            amount_ = MAX_SUPPLY - totalSupply_;\n        }\n        _mint(account_, amount_);\n    }\n}"},"contracts/helpers/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n}"},"contracts/helpers/ERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../interfaces/IERC20.sol\";\nimport \"../interfaces/IERC20Metadata.sol\";\nimport \"./Context.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20PresetMinterPauser}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\n * instead returning `false` on failure. This behavior is nonetheless\n * conventional and does not conflict with the expectations of ERC20\n * applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20 is Context, IERC20, IERC20Metadata {\n    mapping(address => uint256) private _balances;\n\n    mapping(address => mapping(address => uint256)) private _allowances;\n\n    uint256 private _totalSupply;\n\n    string private _name;\n    string private _symbol;\n\n    /**\n     * @dev Sets the values for {name} and {symbol}.\n     *\n     * The default value of {decimals} is 18. To select a different value for\n     * {decimals} you should overload it.\n     *\n     * All two of these values are immutable: they can only be set once during\n     * construction.\n     */\n    constructor(string memory name_, string memory symbol_) {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() public view virtual override returns (string memory) {\n        return _name;\n    }\n\n    /**\n     * @dev Returns the symbol of the token, usually a shorter version of the\n     * name.\n     */\n    function symbol() public view virtual override returns (string memory) {\n        return _symbol;\n    }\n\n    /**\n     * @dev Returns the number of decimals used to get its user representation.\n     * For example, if `decimals` equals `2`, a balance of `505` tokens should\n     * be displayed to a user as `5.05` (`505 / 10 ** 2`).\n     *\n     * Tokens usually opt for a value of 18, imitating the relationship between\n     * Ether and Wei. This is the value {ERC20} uses, unless this function is\n     * overridden;\n     *\n     * NOTE: This information is only used for _display_ purposes: it in\n     * no way affects any of the arithmetic of the contract, including\n     * {IERC20-balanceOf} and {IERC20-transfer}.\n     */\n    function decimals() public view virtual override returns (uint8) {\n        return 18;\n    }\n\n    /**\n     * @dev See {IERC20-totalSupply}.\n     */\n    function totalSupply() public view virtual override returns (uint256) {\n        return _totalSupply;\n    }\n\n    /**\n     * @dev See {IERC20-balanceOf}.\n     */\n    function balanceOf(address account) public view virtual override returns (uint256) {\n        return _balances[account];\n    }\n\n    /**\n     * @dev See {IERC20-transfer}.\n     *\n     * Requirements:\n     *\n     * - `recipient` cannot be the zero address.\n     * - the caller must have a balance of at least `amount`.\n     */\n    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\n        _transfer(_msgSender(), recipient, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-allowance}.\n     */\n    function allowance(address owner, address spender) public view virtual override returns (uint256) {\n        return _allowances[owner][spender];\n    }\n\n    /**\n     * @dev See {IERC20-approve}.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function approve(address spender, uint256 amount) public virtual override returns (bool) {\n        _approve(_msgSender(), spender, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-transferFrom}.\n     *\n     * Emits an {Approval} event indicating the updated allowance. This is not\n     * required by the EIP. See the note at the beginning of {ERC20}.\n     *\n     * Requirements:\n     *\n     * - `sender` and `recipient` cannot be the zero address.\n     * - `sender` must have a balance of at least `amount`.\n     * - the caller must have allowance for ``sender``'s tokens of at least\n     * `amount`.\n     */\n    function transferFrom(\n        address sender,\n        address recipient,\n        uint256 amount\n    ) public virtual override returns (bool) {\n        _transfer(sender, recipient, amount);\n\n        uint256 currentAllowance = _allowances[sender][_msgSender()];\n        require(currentAllowance >= amount, \"ERC20: transfer amount exceeds allowance\");\n        unchecked {\n            _approve(sender, _msgSender(), currentAllowance - amount);\n        }\n\n        return true;\n    }\n\n    /**\n     * @dev Atomically increases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n        _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\n        return true;\n    }\n\n    /**\n     * @dev Atomically decreases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `spender` must have allowance for the caller of at least\n     * `subtractedValue`.\n     */\n    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n        uint256 currentAllowance = _allowances[_msgSender()][spender];\n        require(currentAllowance >= subtractedValue, \"ERC20: decreased allowance below zero\");\n        unchecked {\n            _approve(_msgSender(), spender, currentAllowance - subtractedValue);\n        }\n\n        return true;\n    }\n\n    /**\n     * @dev Moves `amount` of tokens from `sender` to `recipient`.\n     *\n     * This internal function is equivalent to {transfer}, and can be used to\n     * e.g. implement automatic token fees, slashing mechanisms, etc.\n     *\n     * Emits a {Transfer} event.\n     *\n     * Requirements:\n     *\n     * - `sender` cannot be the zero address.\n     * - `recipient` cannot be the zero address.\n     * - `sender` must have a balance of at least `amount`.\n     */\n    function _transfer(\n        address sender,\n        address recipient,\n        uint256 amount\n    ) internal virtual {\n        require(sender != address(0), \"ERC20: transfer from the zero address\");\n        require(recipient != address(0), \"ERC20: transfer to the zero address\");\n\n        _beforeTokenTransfer(sender, recipient, amount);\n\n        uint256 senderBalance = _balances[sender];\n        require(senderBalance >= amount, \"ERC20: transfer amount exceeds balance\");\n        unchecked {\n            _balances[sender] = senderBalance - amount;\n        }\n        _balances[recipient] += amount;\n\n        emit Transfer(sender, recipient, amount);\n\n        _afterTokenTransfer(sender, recipient, amount);\n    }\n\n    /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n     * the total supply.\n     *\n     * Emits a {Transfer} event with `from` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     */\n    function _mint(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: mint to the zero address\");\n\n        _beforeTokenTransfer(address(0), account, amount);\n\n        _totalSupply += amount;\n        _balances[account] += amount;\n        emit Transfer(address(0), account, amount);\n\n        _afterTokenTransfer(address(0), account, amount);\n    }\n\n    /**\n     * @dev Destroys `amount` tokens from `account`, reducing the\n     * total supply.\n     *\n     * Emits a {Transfer} event with `to` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     * - `account` must have at least `amount` tokens.\n     */\n    function _burn(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: burn from the zero address\");\n\n        _beforeTokenTransfer(account, address(0), amount);\n\n        uint256 accountBalance = _balances[account];\n        require(accountBalance >= amount, \"ERC20: burn amount exceeds balance\");\n        unchecked {\n            _balances[account] = accountBalance - amount;\n        }\n        _totalSupply -= amount;\n\n        emit Transfer(account, address(0), amount);\n\n        _afterTokenTransfer(account, address(0), amount);\n    }\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\n     *\n     * This internal function is equivalent to `approve`, and can be used to\n     * e.g. set automatic allowances for certain subsystems, etc.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `owner` cannot be the zero address.\n     * - `spender` cannot be the zero address.\n     */\n    function _approve(\n        address owner,\n        address spender,\n        uint256 amount\n    ) internal virtual {\n        require(owner != address(0), \"ERC20: approve from the zero address\");\n        require(spender != address(0), \"ERC20: approve to the zero address\");\n\n        _allowances[owner][spender] = amount;\n        emit Approval(owner, spender, amount);\n    }\n\n    /**\n     * @dev Hook that is called before any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * will be transferred to `to`.\n     * - when `from` is zero, `amount` tokens will be minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _beforeTokenTransfer(\n        address from,\n        address to,\n        uint256 amount\n    ) internal virtual {}\n\n    /**\n     * @dev Hook that is called after any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * has been transferred to `to`.\n     * - when `from` is zero, `amount` tokens have been minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _afterTokenTransfer(\n        address from,\n        address to,\n        uint256 amount\n    ) internal virtual {}\n}"},"contracts/helpers/Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"./Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n    address private _owner;\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the deployer as the initial owner.\n     */\n    constructor() {\n        _setOwner(_msgSender());\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n        _;\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions anymore. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby removing any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _setOwner(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n        _setOwner(newOwner);\n    }\n\n    function _setOwner(address newOwner) private {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n"},"contracts/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\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 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 `recipient`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address recipient, 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 `sender` to `recipient` 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(\n        address sender,\n        address recipient,\n        uint256 amount\n    ) external returns (bool);\n\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}"},"contracts/interfaces/IERC20Metadata.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"./IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20Metadata is IERC20 {\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the symbol of the token.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the decimals places of the token.\n     */\n    function decimals() external view returns (uint8);\n}"},"contracts/library/SafeMath.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.0;\n\n/**\n * @dev Wrappers over Solidity's arithmetic operations with added overflow\n * checks.\n *\n * Arithmetic operations in Solidity wrap on overflow. This can easily result\n * in bugs, because programmers usually assume that an overflow raises an\n * error, which is the standard behavior in high level programming languages.\n * `SafeMath` restores this intuition by reverting the transaction when an\n * operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n */\nlibrary SafeMath {\n    /**\n     * @dev Returns the addition of two unsigned integers, reverting on\n     * overflow.\n     *\n     * Counterpart to Solidity's `+` operator.\n     *\n     * Requirements:\n     *\n     * - Addition cannot overflow.\n     */\n    function add(uint256 a, uint256 b) internal pure returns (uint256) {\n        uint256 c = a + b;\n        require(c >= a, \"SafeMath: addition overflow\");\n\n        return c;\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, reverting on\n     * overflow (when the result is negative).\n     *\n     * Counterpart to Solidity's `-` operator.\n     *\n     * Requirements:\n     *\n     * - Subtraction cannot overflow.\n     */\n    function sub(uint256 a, uint256 b) internal pure returns (uint256) {\n        return sub(a, b, \"SafeMath: subtraction overflow\");\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\n     * overflow (when the result is negative).\n     *\n     * Counterpart to Solidity's `-` operator.\n     *\n     * Requirements:\n     *\n     * - Subtraction cannot overflow.\n     */\n    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        require(b <= a, errorMessage);\n        uint256 c = a - b;\n\n        return c;\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, reverting on\n     * overflow.\n     *\n     * Counterpart to Solidity's `*` operator.\n     *\n     * Requirements:\n     *\n     * - Multiplication cannot overflow.\n     */\n    function mul(uint256 a, uint256 b) internal pure returns (uint256) {\n        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n        // benefit is lost if 'b' is also tested.\n        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n        if (a == 0) {\n            return 0;\n        }\n\n        uint256 c = a * b;\n        require(c / a == b, \"SafeMath: multiplication overflow\");\n\n        return c;\n    }\n\n    /**\n     * @dev Returns the integer division of two unsigned integers. Reverts on\n     * division by zero. The result is rounded towards zero.\n     *\n     * Counterpart to Solidity's `/` operator. Note: this function uses a\n     * `revert` opcode (which leaves remaining gas untouched) while Solidity\n     * uses an invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function div(uint256 a, uint256 b) internal pure returns (uint256) {\n        return div(a, b, \"SafeMath: division by zero\");\n    }\n\n    /**\n     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on\n     * division by zero. The result is rounded towards zero.\n     *\n     * Counterpart to Solidity's `/` operator. Note: this function uses a\n     * `revert` opcode (which leaves remaining gas untouched) while Solidity\n     * uses an invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        require(b > 0, errorMessage);\n        uint256 c = a / b;\n        // assert(a == b * c + a % b); // There is no case in which this doesn't hold\n\n        return c;\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n     * Reverts when dividing by zero.\n     *\n     * Counterpart to Solidity's `%` operator. This function uses a `revert`\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\n     * invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function mod(uint256 a, uint256 b) internal pure returns (uint256) {\n        return mod(a, b, \"SafeMath: modulo by zero\");\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n     * Reverts with custom message when dividing by zero.\n     *\n     * Counterpart to Solidity's `%` operator. This function uses a `revert`\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\n     * invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        require(b != 0, errorMessage);\n        return a % b;\n    }\n\n    function sqrrt(uint256 a) internal pure returns (uint c) {\n        if (a > 3) {\n            c = a;\n            uint b = add( div( a, 2), 1 );\n            while (b < c) {\n                c = b;\n                b = div( add( div( a, b ), b), 2 );\n            }\n        } else if (a != 0) {\n            c = 1;\n        }\n    }\n\n    function min(uint x, uint y) internal pure returns (uint z) {\n        z = x < y ? x : y;\n    }\n}"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.0+commit.c7dfd78e","compilerSettings":{"libraries":{},"optimizer":{"runs":200,"enabled":true}},"name":"Beat","fullyQualifiedName":"contracts/Beat.sol:Beat"},"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"name":"Approval","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"spender","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Transfer","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"MAX_SUPPLY","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"allowance","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"approve","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"balanceOf","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"decimals","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"decreaseAllowance","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"subtractedValue","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"increaseAllowance","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"addedValue","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"mint","type":"function","inputs":[{"name":"account_","type":"address","internalType":"address"},{"name":"amount_","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"name","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"totalSupply","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transfer","type":"function","inputs":[{"name":"recipient","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferFrom","type":"function","inputs":[{"name":"sender","type":"address","internalType":"address"},{"name":"recipient","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"}],"metadata":{"compiler":{"version":"0.8.0+commit.c7dfd78e"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account_","type":"address"},{"internalType":"uint256","name":"amount_","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}],"devdoc":{"kind":"dev","methods":{"allowance(address,address)":{"details":"See {IERC20-allowance}."},"approve(address,uint256)":{"details":"See {IERC20-approve}. Requirements: - `spender` cannot be the zero address."},"balanceOf(address)":{"details":"See {IERC20-balanceOf}."},"decimals()":{"details":"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the value {ERC20} uses, unless this function is overridden; NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}."},"decreaseAllowance(address,uint256)":{"details":"Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`."},"increaseAllowance(address,uint256)":{"details":"Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address."},"name()":{"details":"Returns the name of the token."},"owner()":{"details":"Returns the address of the current owner."},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner."},"symbol()":{"details":"Returns the symbol of the token, usually a shorter version of the name."},"totalSupply()":{"details":"See {IERC20-totalSupply}."},"transfer(address,uint256)":{"details":"See {IERC20-transfer}. Requirements: - `recipient` cannot be the zero address. - the caller must have a balance of at least `amount`."},"transferFrom(address,address,uint256)":{"details":"See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. Requirements: - `sender` and `recipient` cannot be the zero address. - `sender` must have a balance of at least `amount`. - the caller must have allowance for ``sender``'s tokens of at least `amount`."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."}},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"compilationTarget":{"contracts/Beat.sol":"Beat"},"evmVersion":"istanbul","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":200},"remappings":[]},"sources":{"contracts/Beat.sol":{"keccak256":"0x9a2eb272b2e20d34463bca38f934c5551332d8e4db3c19fbdb464cf4da31f14d","license":"MIT","urls":["bzz-raw://f8e73f318fbc3bf54921ee272e1b71d9f564532ec3b6a439308cac6ced2315fa","dweb:/ipfs/QmXBUtPBA9yPzyrrQkGNuqcHp5vJkJMTmFQR7V78RQG1oY"]},"contracts/helpers/Context.sol":{"keccak256":"0x45cb9d70dc84e6f4ec8202a58599a881421174348e0fd4400a99a22678aa7913","license":"MIT","urls":["bzz-raw://640ea1ba9707020a73d52eb62afcc682aa0a502e61378ff2e3ed7be701afcaaf","dweb:/ipfs/QmPup8KPcQQXcz4qz9r1G4ks7bv8jLqrcWNruZyXTto6qy"]},"contracts/helpers/ERC20.sol":{"keccak256":"0xce7fe9653f501bb602a1dc5af2f882952472d43e6e41ce2391d6466d9d830d5b","license":"MIT","urls":["bzz-raw://f901f82b8378aad97befa162b36427068f05569d4487888fff3fe2d0a88b24a5","dweb:/ipfs/QmTR4Rn41aSzRugq2urskEGYwrutN2tNJ5a1aUPTY3f4Sq"]},"contracts/helpers/Ownable.sol":{"keccak256":"0x75d1e6250c190ca0500e5a2b7def5e5d6fd3edbe368a6de93dea256471d04593","license":"MIT","urls":["bzz-raw://09b8acacbbc0353985940f90022a8e15d15d9767e1eeaa721e1e21655c34c62e","dweb:/ipfs/Qmeb2CejPutKdfNpncsRny8cibhF7aVMJpR6ZvMYruDWLM"]},"contracts/interfaces/IERC20.sol":{"keccak256":"0xb55c91551ef864f86edd296378fc3430f19798c0d1de468ff772a83a842df24c","license":"MIT","urls":["bzz-raw://f118e5d475795b9e612bb6c139db18493e65f47f181ddcef446f4fa43e7f80f5","dweb:/ipfs/QmSRWmUWxpjp8jMtDHqWysWbZqFNVKAyLHcmBtjJRvmoLF"]},"contracts/interfaces/IERC20Metadata.sol":{"keccak256":"0x4065401847859fdea8270079da0d5d94d4d6bcb16b83753f25d77c03bc9fa66d","license":"MIT","urls":["bzz-raw://ddc99a4763150db86205a0b0313dda9db3b4c1cc283933cb9228d63ea71a7495","dweb:/ipfs/QmaVKXyFDwYPZ1iRrjAEbbaFYWSfrYdz4jfaeFJ7EWzT6k"]},"contracts/library/SafeMath.sol":{"keccak256":"0xcec240cd1142a7a9e0e0e3d3bdce3ab5aba85e3e66fd93c827bf594cd7566cdd","license":"MIT","urls":["bzz-raw://4da963c825ca57cea03a4727d527baa1922b04c9230b61da3b8378951da4bda8","dweb:/ipfs/QmP8G1oqfKbC563MeFGBca9LUwhM16t2TxSK1NwdjaMnhf"]}},"version":1},"storageLayout":{"types":{"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_string_storage":{"label":"string","encoding":"bytes","numberOfBytes":"32"},"t_mapping(t_address,t_uint256)":{"key":"t_address","label":"mapping(address => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_address,t_uint256))":{"key":"t_address","label":"mapping(address => mapping(address => uint256))","value":"t_mapping(t_address,t_uint256)","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_mapping(t_address,t_uint256)","astId":98,"label":"_balances","offset":0,"contract":"contracts/Beat.sol:Beat"},{"slot":"1","type":"t_mapping(t_address,t_mapping(t_address,t_uint256))","astId":104,"label":"_allowances","offset":0,"contract":"contracts/Beat.sol:Beat"},{"slot":"2","type":"t_uint256","astId":106,"label":"_totalSupply","offset":0,"contract":"contracts/Beat.sol:Beat"},{"slot":"3","type":"t_string_storage","astId":108,"label":"_name","offset":0,"contract":"contracts/Beat.sol:Beat"},{"slot":"4","type":"t_string_storage","astId":110,"label":"_symbol","offset":0,"contract":"contracts/Beat.sol:Beat"},{"slot":"5","type":"t_address","astId":636,"label":"_owner","offset":0,"contract":"contracts/Beat.sol:Beat"}]},"transientStorageLayout":null,"userdoc":{"kind":"user","methods":{},"version":1},"devdoc":{"kind":"dev","methods":{"name()":{"details":"Returns the name of the token."},"owner()":{"details":"Returns the address of the current owner."},"symbol()":{"details":"Returns the symbol of the token, usually a shorter version of the name."},"decimals()":{"details":"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the value {ERC20} uses, unless this function is overridden; NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}."},"totalSupply()":{"details":"See {IERC20-totalSupply}."},"balanceOf(address)":{"details":"See {IERC20-balanceOf}."},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner."},"approve(address,uint256)":{"details":"See {IERC20-approve}. Requirements: - `spender` cannot be the zero address."},"transfer(address,uint256)":{"details":"See {IERC20-transfer}. Requirements: - `recipient` cannot be the zero address. - the caller must have a balance of at least `amount`."},"allowance(address,address)":{"details":"See {IERC20-allowance}."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"decreaseAllowance(address,uint256)":{"details":"Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`."},"increaseAllowance(address,uint256)":{"details":"Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address."},"transferFrom(address,address,uint256)":{"details":"See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. Requirements: - `sender` and `recipient` cannot be the zero address. - `sender` must have a balance of at least `amount`. - the caller must have allowance for ``sender``'s tokens of at least `amount`."}},"version":1},"sourceIds":{"contracts/Beat.sol":{"id":0},"contracts/helpers/ERC20.sol":{"id":2},"contracts/helpers/Context.sol":{"id":1},"contracts/helpers/Ownable.sol":{"id":3},"contracts/library/SafeMath.sol":{"id":6},"contracts/interfaces/IERC20.sol":{"id":4},"contracts/interfaces/IERC20Metadata.sol":{"id":5}},"additionalInput":null,"stdJsonInput":{"sources":{"contracts/Beat.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\nimport \"./library/SafeMath.sol\";\nimport \"./helpers/ERC20.sol\";\nimport \"./helpers/Ownable.sol\";\n\ncontract Beat is ERC20, Ownable {\n\n    using SafeMath for uint256;\n    uint256 public constant MAX_SUPPLY = 1000000000 * 10**18;\n\n    constructor() ERC20(\"Beat Token\", \"Beat\") {\n    }\n\n    function mint(address account_, uint256 amount_) external onlyOwner() {\n        uint256 totalSupply_ = totalSupply();\n        if (amount_ + totalSupply_ > MAX_SUPPLY) {\n            amount_ = MAX_SUPPLY - totalSupply_;\n        }\n        _mint(account_, amount_);\n    }\n}"},"contracts/helpers/ERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../interfaces/IERC20.sol\";\nimport \"../interfaces/IERC20Metadata.sol\";\nimport \"./Context.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20PresetMinterPauser}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\n * instead returning `false` on failure. This behavior is nonetheless\n * conventional and does not conflict with the expectations of ERC20\n * applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20 is Context, IERC20, IERC20Metadata {\n    mapping(address => uint256) private _balances;\n\n    mapping(address => mapping(address => uint256)) private _allowances;\n\n    uint256 private _totalSupply;\n\n    string private _name;\n    string private _symbol;\n\n    /**\n     * @dev Sets the values for {name} and {symbol}.\n     *\n     * The default value of {decimals} is 18. To select a different value for\n     * {decimals} you should overload it.\n     *\n     * All two of these values are immutable: they can only be set once during\n     * construction.\n     */\n    constructor(string memory name_, string memory symbol_) {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() public view virtual override returns (string memory) {\n        return _name;\n    }\n\n    /**\n     * @dev Returns the symbol of the token, usually a shorter version of the\n     * name.\n     */\n    function symbol() public view virtual override returns (string memory) {\n        return _symbol;\n    }\n\n    /**\n     * @dev Returns the number of decimals used to get its user representation.\n     * For example, if `decimals` equals `2`, a balance of `505` tokens should\n     * be displayed to a user as `5.05` (`505 / 10 ** 2`).\n     *\n     * Tokens usually opt for a value of 18, imitating the relationship between\n     * Ether and Wei. This is the value {ERC20} uses, unless this function is\n     * overridden;\n     *\n     * NOTE: This information is only used for _display_ purposes: it in\n     * no way affects any of the arithmetic of the contract, including\n     * {IERC20-balanceOf} and {IERC20-transfer}.\n     */\n    function decimals() public view virtual override returns (uint8) {\n        return 18;\n    }\n\n    /**\n     * @dev See {IERC20-totalSupply}.\n     */\n    function totalSupply() public view virtual override returns (uint256) {\n        return _totalSupply;\n    }\n\n    /**\n     * @dev See {IERC20-balanceOf}.\n     */\n    function balanceOf(address account) public view virtual override returns (uint256) {\n        return _balances[account];\n    }\n\n    /**\n     * @dev See {IERC20-transfer}.\n     *\n     * Requirements:\n     *\n     * - `recipient` cannot be the zero address.\n     * - the caller must have a balance of at least `amount`.\n     */\n    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\n        _transfer(_msgSender(), recipient, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-allowance}.\n     */\n    function allowance(address owner, address spender) public view virtual override returns (uint256) {\n        return _allowances[owner][spender];\n    }\n\n    /**\n     * @dev See {IERC20-approve}.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function approve(address spender, uint256 amount) public virtual override returns (bool) {\n        _approve(_msgSender(), spender, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-transferFrom}.\n     *\n     * Emits an {Approval} event indicating the updated allowance. This is not\n     * required by the EIP. See the note at the beginning of {ERC20}.\n     *\n     * Requirements:\n     *\n     * - `sender` and `recipient` cannot be the zero address.\n     * - `sender` must have a balance of at least `amount`.\n     * - the caller must have allowance for ``sender``'s tokens of at least\n     * `amount`.\n     */\n    function transferFrom(\n        address sender,\n        address recipient,\n        uint256 amount\n    ) public virtual override returns (bool) {\n        _transfer(sender, recipient, amount);\n\n        uint256 currentAllowance = _allowances[sender][_msgSender()];\n        require(currentAllowance >= amount, \"ERC20: transfer amount exceeds allowance\");\n        unchecked {\n            _approve(sender, _msgSender(), currentAllowance - amount);\n        }\n\n        return true;\n    }\n\n    /**\n     * @dev Atomically increases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n        _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\n        return true;\n    }\n\n    /**\n     * @dev Atomically decreases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `spender` must have allowance for the caller of at least\n     * `subtractedValue`.\n     */\n    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n        uint256 currentAllowance = _allowances[_msgSender()][spender];\n        require(currentAllowance >= subtractedValue, \"ERC20: decreased allowance below zero\");\n        unchecked {\n            _approve(_msgSender(), spender, currentAllowance - subtractedValue);\n        }\n\n        return true;\n    }\n\n    /**\n     * @dev Moves `amount` of tokens from `sender` to `recipient`.\n     *\n     * This internal function is equivalent to {transfer}, and can be used to\n     * e.g. implement automatic token fees, slashing mechanisms, etc.\n     *\n     * Emits a {Transfer} event.\n     *\n     * Requirements:\n     *\n     * - `sender` cannot be the zero address.\n     * - `recipient` cannot be the zero address.\n     * - `sender` must have a balance of at least `amount`.\n     */\n    function _transfer(\n        address sender,\n        address recipient,\n        uint256 amount\n    ) internal virtual {\n        require(sender != address(0), \"ERC20: transfer from the zero address\");\n        require(recipient != address(0), \"ERC20: transfer to the zero address\");\n\n        _beforeTokenTransfer(sender, recipient, amount);\n\n        uint256 senderBalance = _balances[sender];\n        require(senderBalance >= amount, \"ERC20: transfer amount exceeds balance\");\n        unchecked {\n            _balances[sender] = senderBalance - amount;\n        }\n        _balances[recipient] += amount;\n\n        emit Transfer(sender, recipient, amount);\n\n        _afterTokenTransfer(sender, recipient, amount);\n    }\n\n    /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n     * the total supply.\n     *\n     * Emits a {Transfer} event with `from` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     */\n    function _mint(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: mint to the zero address\");\n\n        _beforeTokenTransfer(address(0), account, amount);\n\n        _totalSupply += amount;\n        _balances[account] += amount;\n        emit Transfer(address(0), account, amount);\n\n        _afterTokenTransfer(address(0), account, amount);\n    }\n\n    /**\n     * @dev Destroys `amount` tokens from `account`, reducing the\n     * total supply.\n     *\n     * Emits a {Transfer} event with `to` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     * - `account` must have at least `amount` tokens.\n     */\n    function _burn(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: burn from the zero address\");\n\n        _beforeTokenTransfer(account, address(0), amount);\n\n        uint256 accountBalance = _balances[account];\n        require(accountBalance >= amount, \"ERC20: burn amount exceeds balance\");\n        unchecked {\n            _balances[account] = accountBalance - amount;\n        }\n        _totalSupply -= amount;\n\n        emit Transfer(account, address(0), amount);\n\n        _afterTokenTransfer(account, address(0), amount);\n    }\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\n     *\n     * This internal function is equivalent to `approve`, and can be used to\n     * e.g. set automatic allowances for certain subsystems, etc.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `owner` cannot be the zero address.\n     * - `spender` cannot be the zero address.\n     */\n    function _approve(\n        address owner,\n        address spender,\n        uint256 amount\n    ) internal virtual {\n        require(owner != address(0), \"ERC20: approve from the zero address\");\n        require(spender != address(0), \"ERC20: approve to the zero address\");\n\n        _allowances[owner][spender] = amount;\n        emit Approval(owner, spender, amount);\n    }\n\n    /**\n     * @dev Hook that is called before any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * will be transferred to `to`.\n     * - when `from` is zero, `amount` tokens will be minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _beforeTokenTransfer(\n        address from,\n        address to,\n        uint256 amount\n    ) internal virtual {}\n\n    /**\n     * @dev Hook that is called after any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * has been transferred to `to`.\n     * - when `from` is zero, `amount` tokens have been minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _afterTokenTransfer(\n        address from,\n        address to,\n        uint256 amount\n    ) internal virtual {}\n}"},"contracts/helpers/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n}"},"contracts/helpers/Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"./Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n    address private _owner;\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the deployer as the initial owner.\n     */\n    constructor() {\n        _setOwner(_msgSender());\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n        _;\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions anymore. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby removing any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _setOwner(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n        _setOwner(newOwner);\n    }\n\n    function _setOwner(address newOwner) private {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n"},"contracts/library/SafeMath.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.0;\n\n/**\n * @dev Wrappers over Solidity's arithmetic operations with added overflow\n * checks.\n *\n * Arithmetic operations in Solidity wrap on overflow. This can easily result\n * in bugs, because programmers usually assume that an overflow raises an\n * error, which is the standard behavior in high level programming languages.\n * `SafeMath` restores this intuition by reverting the transaction when an\n * operation overflows.\n *\n * Using this library instead of the unchecked operations eliminates an entire\n * class of bugs, so it's recommended to use it always.\n */\nlibrary SafeMath {\n    /**\n     * @dev Returns the addition of two unsigned integers, reverting on\n     * overflow.\n     *\n     * Counterpart to Solidity's `+` operator.\n     *\n     * Requirements:\n     *\n     * - Addition cannot overflow.\n     */\n    function add(uint256 a, uint256 b) internal pure returns (uint256) {\n        uint256 c = a + b;\n        require(c >= a, \"SafeMath: addition overflow\");\n\n        return c;\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, reverting on\n     * overflow (when the result is negative).\n     *\n     * Counterpart to Solidity's `-` operator.\n     *\n     * Requirements:\n     *\n     * - Subtraction cannot overflow.\n     */\n    function sub(uint256 a, uint256 b) internal pure returns (uint256) {\n        return sub(a, b, \"SafeMath: subtraction overflow\");\n    }\n\n    /**\n     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\n     * overflow (when the result is negative).\n     *\n     * Counterpart to Solidity's `-` operator.\n     *\n     * Requirements:\n     *\n     * - Subtraction cannot overflow.\n     */\n    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        require(b <= a, errorMessage);\n        uint256 c = a - b;\n\n        return c;\n    }\n\n    /**\n     * @dev Returns the multiplication of two unsigned integers, reverting on\n     * overflow.\n     *\n     * Counterpart to Solidity's `*` operator.\n     *\n     * Requirements:\n     *\n     * - Multiplication cannot overflow.\n     */\n    function mul(uint256 a, uint256 b) internal pure returns (uint256) {\n        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\n        // benefit is lost if 'b' is also tested.\n        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\n        if (a == 0) {\n            return 0;\n        }\n\n        uint256 c = a * b;\n        require(c / a == b, \"SafeMath: multiplication overflow\");\n\n        return c;\n    }\n\n    /**\n     * @dev Returns the integer division of two unsigned integers. Reverts on\n     * division by zero. The result is rounded towards zero.\n     *\n     * Counterpart to Solidity's `/` operator. Note: this function uses a\n     * `revert` opcode (which leaves remaining gas untouched) while Solidity\n     * uses an invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function div(uint256 a, uint256 b) internal pure returns (uint256) {\n        return div(a, b, \"SafeMath: division by zero\");\n    }\n\n    /**\n     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on\n     * division by zero. The result is rounded towards zero.\n     *\n     * Counterpart to Solidity's `/` operator. Note: this function uses a\n     * `revert` opcode (which leaves remaining gas untouched) while Solidity\n     * uses an invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        require(b > 0, errorMessage);\n        uint256 c = a / b;\n        // assert(a == b * c + a % b); // There is no case in which this doesn't hold\n\n        return c;\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n     * Reverts when dividing by zero.\n     *\n     * Counterpart to Solidity's `%` operator. This function uses a `revert`\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\n     * invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function mod(uint256 a, uint256 b) internal pure returns (uint256) {\n        return mod(a, b, \"SafeMath: modulo by zero\");\n    }\n\n    /**\n     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\n     * Reverts with custom message when dividing by zero.\n     *\n     * Counterpart to Solidity's `%` operator. This function uses a `revert`\n     * opcode (which leaves remaining gas untouched) while Solidity uses an\n     * invalid opcode to revert (consuming all remaining gas).\n     *\n     * Requirements:\n     *\n     * - The divisor cannot be zero.\n     */\n    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\n        require(b != 0, errorMessage);\n        return a % b;\n    }\n\n    function sqrrt(uint256 a) internal pure returns (uint c) {\n        if (a > 3) {\n            c = a;\n            uint b = add( div( a, 2), 1 );\n            while (b < c) {\n                c = b;\n                b = div( add( div( a, b ), b), 2 );\n            }\n        } else if (a != 0) {\n            c = 1;\n        }\n    }\n\n    function min(uint x, uint y) internal pure returns (uint z) {\n        z = x < y ? x : y;\n    }\n}"},"contracts/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\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 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 `recipient`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address recipient, 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 `sender` to `recipient` 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(\n        address sender,\n        address recipient,\n        uint256 amount\n    ) external returns (bool);\n\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}"},"contracts/interfaces/IERC20Metadata.sol":{"content":"// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"./IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20Metadata is IERC20 {\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the symbol of the token.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the decimals places of the token.\n     */\n    function decimals() external view returns (uint8);\n}"}},"language":"Solidity","settings":{"libraries":{},"optimizer":{"runs":200,"enabled":true}}},"stdJsonOutput":{"sources":{"contracts/Beat.sol":{"id":0},"contracts/helpers/ERC20.sol":{"id":2},"contracts/helpers/Context.sol":{"id":1},"contracts/helpers/Ownable.sol":{"id":3},"contracts/library/SafeMath.sol":{"id":6},"contracts/interfaces/IERC20.sol":{"id":4},"contracts/interfaces/IERC20Metadata.sol":{"id":5}},"contracts":{"contracts/Beat.sol":{"Beat":{"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"name":"Approval","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"spender","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Transfer","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"MAX_SUPPLY","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"allowance","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"approve","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"balanceOf","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"decimals","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"decreaseAllowance","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"subtractedValue","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"increaseAllowance","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"addedValue","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"mint","type":"function","inputs":[{"name":"account_","type":"address","internalType":"address"},{"name":"amount_","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"name","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"totalSupply","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transfer","type":"function","inputs":[{"name":"recipient","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferFrom","type":"function","inputs":[{"name":"sender","type":"address","internalType":"address"},{"name":"recipient","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.0+commit.c7dfd78e\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"MAX_SUPPLY\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account_\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount_\",\"type\":\"uint256\"}],\"name\":\"mint\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"allowance(address,address)\":{\"details\":\"See {IERC20-allowance}.\"},\"approve(address,uint256)\":{\"details\":\"See {IERC20-approve}. Requirements: - `spender` cannot be the zero address.\"},\"balanceOf(address)\":{\"details\":\"See {IERC20-balanceOf}.\"},\"decimals()\":{\"details\":\"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the value {ERC20} uses, unless this function is overridden; NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}.\"},\"decreaseAllowance(address,uint256)\":{\"details\":\"Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`.\"},\"increaseAllowance(address,uint256)\":{\"details\":\"Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address.\"},\"name()\":{\"details\":\"Returns the name of the token.\"},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner.\"},\"symbol()\":{\"details\":\"Returns the symbol of the token, usually a shorter version of the name.\"},\"totalSupply()\":{\"details\":\"See {IERC20-totalSupply}.\"},\"transfer(address,uint256)\":{\"details\":\"See {IERC20-transfer}. Requirements: - `recipient` cannot be the zero address. - the caller must have a balance of at least `amount`.\"},\"transferFrom(address,address,uint256)\":{\"details\":\"See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. Requirements: - `sender` and `recipient` cannot be the zero address. - `sender` must have a balance of at least `amount`. - the caller must have allowance for ``sender``'s tokens of at least `amount`.\"},\"transferOwnership(address)\":{\"details\":\"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/Beat.sol\":\"Beat\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"contracts/Beat.sol\":{\"keccak256\":\"0x9a2eb272b2e20d34463bca38f934c5551332d8e4db3c19fbdb464cf4da31f14d\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f8e73f318fbc3bf54921ee272e1b71d9f564532ec3b6a439308cac6ced2315fa\",\"dweb:/ipfs/QmXBUtPBA9yPzyrrQkGNuqcHp5vJkJMTmFQR7V78RQG1oY\"]},\"contracts/helpers/Context.sol\":{\"keccak256\":\"0x45cb9d70dc84e6f4ec8202a58599a881421174348e0fd4400a99a22678aa7913\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://640ea1ba9707020a73d52eb62afcc682aa0a502e61378ff2e3ed7be701afcaaf\",\"dweb:/ipfs/QmPup8KPcQQXcz4qz9r1G4ks7bv8jLqrcWNruZyXTto6qy\"]},\"contracts/helpers/ERC20.sol\":{\"keccak256\":\"0xce7fe9653f501bb602a1dc5af2f882952472d43e6e41ce2391d6466d9d830d5b\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f901f82b8378aad97befa162b36427068f05569d4487888fff3fe2d0a88b24a5\",\"dweb:/ipfs/QmTR4Rn41aSzRugq2urskEGYwrutN2tNJ5a1aUPTY3f4Sq\"]},\"contracts/helpers/Ownable.sol\":{\"keccak256\":\"0x75d1e6250c190ca0500e5a2b7def5e5d6fd3edbe368a6de93dea256471d04593\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://09b8acacbbc0353985940f90022a8e15d15d9767e1eeaa721e1e21655c34c62e\",\"dweb:/ipfs/Qmeb2CejPutKdfNpncsRny8cibhF7aVMJpR6ZvMYruDWLM\"]},\"contracts/interfaces/IERC20.sol\":{\"keccak256\":\"0xb55c91551ef864f86edd296378fc3430f19798c0d1de468ff772a83a842df24c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f118e5d475795b9e612bb6c139db18493e65f47f181ddcef446f4fa43e7f80f5\",\"dweb:/ipfs/QmSRWmUWxpjp8jMtDHqWysWbZqFNVKAyLHcmBtjJRvmoLF\"]},\"contracts/interfaces/IERC20Metadata.sol\":{\"keccak256\":\"0x4065401847859fdea8270079da0d5d94d4d6bcb16b83753f25d77c03bc9fa66d\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://ddc99a4763150db86205a0b0313dda9db3b4c1cc283933cb9228d63ea71a7495\",\"dweb:/ipfs/QmaVKXyFDwYPZ1iRrjAEbbaFYWSfrYdz4jfaeFJ7EWzT6k\"]},\"contracts/library/SafeMath.sol\":{\"keccak256\":\"0xcec240cd1142a7a9e0e0e3d3bdce3ab5aba85e3e66fd93c827bf594cd7566cdd\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://4da963c825ca57cea03a4727d527baa1922b04c9230b61da3b8378951da4bda8\",\"dweb:/ipfs/QmP8G1oqfKbC563MeFGBca9LUwhM16t2TxSK1NwdjaMnhf\"]}},\"version\":1}","userdoc":{"kind":"user","methods":{},"version":1},"devdoc":{"kind":"dev","methods":{"name()":{"details":"Returns the name of the token."},"owner()":{"details":"Returns the address of the current owner."},"symbol()":{"details":"Returns the symbol of the token, usually a shorter version of the name."},"decimals()":{"details":"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the value {ERC20} uses, unless this function is overridden; NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}."},"totalSupply()":{"details":"See {IERC20-totalSupply}."},"balanceOf(address)":{"details":"See {IERC20-balanceOf}."},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner."},"approve(address,uint256)":{"details":"See {IERC20-approve}. Requirements: - `spender` cannot be the zero address."},"transfer(address,uint256)":{"details":"See {IERC20-transfer}. Requirements: - `recipient` cannot be the zero address. - the caller must have a balance of at least `amount`."},"allowance(address,address)":{"details":"See {IERC20-allowance}."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"decreaseAllowance(address,uint256)":{"details":"Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`."},"increaseAllowance(address,uint256)":{"details":"Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address."},"transferFrom(address,address,uint256)":{"details":"See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. Requirements: - `sender` and `recipient` cannot be the zero address. - `sender` must have a balance of at least `amount`. - the caller must have allowance for ``sender``'s tokens of at least `amount`."}},"version":1},"storageLayout":{"types":{"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_string_storage":{"label":"string","encoding":"bytes","numberOfBytes":"32"},"t_mapping(t_address,t_uint256)":{"key":"t_address","label":"mapping(address => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_address,t_uint256))":{"key":"t_address","label":"mapping(address => mapping(address => uint256))","value":"t_mapping(t_address,t_uint256)","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_mapping(t_address,t_uint256)","astId":98,"label":"_balances","offset":0,"contract":"contracts/Beat.sol:Beat"},{"slot":"1","type":"t_mapping(t_address,t_mapping(t_address,t_uint256))","astId":104,"label":"_allowances","offset":0,"contract":"contracts/Beat.sol:Beat"},{"slot":"2","type":"t_uint256","astId":106,"label":"_totalSupply","offset":0,"contract":"contracts/Beat.sol:Beat"},{"slot":"3","type":"t_string_storage","astId":108,"label":"_name","offset":0,"contract":"contracts/Beat.sol:Beat"},{"slot":"4","type":"t_string_storage","astId":110,"label":"_symbol","offset":0,"contract":"contracts/Beat.sol:Beat"},{"slot":"5","type":"t_address","astId":636,"label":"_owner","offset":0,"contract":"contracts/Beat.sol:Beat"}]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"152:458:0:-:0;;;286:49;;;;;;;;;-1:-1:-1;1909:113:2;;;;;;;;;;;-1:-1:-1;;;1909:113:2;;;;;;;;;;;;;;;;;;-1:-1:-1;;;1909:113:2;;;;1975:13;;1909:113;;;1975:13;;:5;;:13;:::i;:::-;-1:-1:-1;1998:17:2;;;;:7;;:17;;;;;:::i;:::-;;1909:113;;860:23:3;870:12;:10;;;:12;;:::i;:::-;860:9;:23::i;:::-;152:458:0;;587:96:1;666:10;587:96;:::o;2034:169:3:-;2108:6;;;-1:-1:-1;;;;;2124:17:3;;;-1:-1:-1;;;;;;2124:17:3;;;;;;;2156:40;;2108:6;;;2124:17;2108:6;;2156:40;;2089:16;;2156:40;2034:169;;:::o;152:458:0:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;152:458:0;;;-1:-1:-1;152:458:0;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:380:7;99:1;89:12;;146:1;136:12;;;157:2;;211:4;203:6;199:17;189:27;;157:2;264;256:6;253:14;233:18;230:38;227:2;;;310:10;305:3;301:20;298:1;291:31;345:4;342:1;335:15;373:4;370:1;363:15;227:2;;69:325;;;:::o;:::-;152:458:0;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"152:458:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2087:98:2;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4184:166;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;3175:106::-;;;:::i;:::-;;;;;;;:::i;4817:478::-;;;;;;:::i;:::-;;:::i;3024:91::-;;;:::i;:::-;;;;;;;:::i;223:56:0:-;;;:::i;5690:212:2:-;;;;;;:::i;:::-;;:::i;341:267:0:-;;;;;;:::i;:::-;;:::i;:::-;;3339:125:2;;;;;;:::i;:::-;;:::i;1598:92:3:-;;;:::i;966:85::-;;;:::i;:::-;;;;;;;:::i;2298:102:2:-;;;:::i;6389:405::-;;;;;;:::i;:::-;;:::i;3667:172::-;;;;;;:::i;:::-;;:::i;3897:149::-;;;;;;:::i;:::-;;:::i;1839:189:3:-;;;;;;:::i;:::-;;:::i;2087:98:2:-;2141:13;2173:5;2166:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2087:98;:::o;4184:166::-;4267:4;4283:39;4292:12;:10;:12::i;:::-;4306:7;4315:6;4283:8;:39::i;:::-;-1:-1:-1;4339:4:2;4184:166;;;;:::o;3175:106::-;3262:12;;3175:106;:::o;4817:478::-;4953:4;4969:36;4979:6;4987:9;4998:6;4969:9;:36::i;:::-;-1:-1:-1;;;;;5043:19:2;;5016:24;5043:19;;;:11;:19;;;;;5016:24;5063:12;:10;:12::i;:::-;-1:-1:-1;;;;;5043:33:2;-1:-1:-1;;;;;5043:33:2;;;;;;;;;;;;;5016:60;;5114:6;5094:16;:26;;5086:79;;;;-1:-1:-1;;;5086:79:2;;;;;;;:::i;:::-;;;;;;;;;5199:57;5208:6;5216:12;:10;:12::i;:::-;5249:6;5230:16;:25;5199:8;:57::i;:::-;-1:-1:-1;5284:4:2;;4817:478;-1:-1:-1;;;;4817:478:2:o;3024:91::-;3106:2;3024:91;:::o;223:56:0:-;260:19;223:56;:::o;5690:212:2:-;5778:4;5794:80;5803:12;:10;:12::i;:::-;5817:7;5863:10;5826:11;:25;5838:12;:10;:12::i;:::-;-1:-1:-1;;;;;5826:25:2;;;;;;;;;;;;;;;;;-1:-1:-1;5826:25:2;;;:34;;;;;;;;;;:47;;;;:::i;:::-;5794:8;:80::i;341:267:0:-;1189:12:3;:10;:12::i;:::-;-1:-1:-1;;;;;1178:23:3;:7;:5;:7::i;:::-;-1:-1:-1;;;;;1178:23:3;;1170:68;;;;-1:-1:-1;;;1170:68:3;;;;;;;:::i;:::-;421:20:0::1;444:13;:11;:13::i;:::-;421:36:::0;-1:-1:-1;260:19:0::1;471:22;421:36:::0;471:7;:22:::1;:::i;:::-;:35;467:101;;;532:25;545:12:::0;260:19:::1;532:25;:::i;:::-;522:35;;467:101;577:24;583:8;593:7;577:5;:24::i;:::-;1248:1:3;341:267:0::0;;:::o;3339:125:2:-;-1:-1:-1;;;;;3439:18:2;;3413:7;3439:18;;;;;;;;;;;3339:125;;;;:::o;1598:92:3:-;1189:12;:10;:12::i;:::-;-1:-1:-1;;;;;1178:23:3;:7;:5;:7::i;:::-;-1:-1:-1;;;;;1178:23:3;;1170:68;;;;-1:-1:-1;;;1170:68:3;;;;;;;:::i;:::-;1662:21:::1;1680:1;1662:9;:21::i;:::-;1598:92::o:0;966:85::-;1038:6;;-1:-1:-1;;;;;1038:6:3;966:85;:::o;2298:102:2:-;2354:13;2386:7;2379:14;;;;;:::i;6389:405::-;6482:4;6498:24;6525:11;:25;6537:12;:10;:12::i;:::-;-1:-1:-1;;;;;6525:25:2;;;;;;;;;;;;;;;;;-1:-1:-1;6525:25:2;;;:34;;;;;;;;;;;-1:-1:-1;6577:35:2;;;;6569:85;;;;-1:-1:-1;;;6569:85:2;;;;;;;:::i;:::-;6688:67;6697:12;:10;:12::i;:::-;6711:7;6739:15;6720:16;:34;6688:8;:67::i;:::-;-1:-1:-1;6783:4:2;;6389:405;-1:-1:-1;;;6389:405:2:o;3667:172::-;3753:4;3769:42;3779:12;:10;:12::i;:::-;3793:9;3804:6;3769:9;:42::i;3897:149::-;-1:-1:-1;;;;;4012:18:2;;;3986:7;4012:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;3897:149::o;1839:189:3:-;1189:12;:10;:12::i;:::-;-1:-1:-1;;;;;1178:23:3;:7;:5;:7::i;:::-;-1:-1:-1;;;;;1178:23:3;;1170:68;;;;-1:-1:-1;;;1170:68:3;;;;;;;:::i;:::-;-1:-1:-1;;;;;1927:22:3;::::1;1919:73;;;;-1:-1:-1::0;;;1919:73:3::1;;;;;;;:::i;:::-;2002:19;2012:8;2002:9;:19::i;:::-;1839:189:::0;:::o;587:96:1:-;666:10;587:96;:::o;9965:370:2:-;-1:-1:-1;;;;;10096:19:2;;10088:68;;;;-1:-1:-1;;;10088:68:2;;;;;;;:::i;:::-;-1:-1:-1;;;;;10174:21:2;;10166:68;;;;-1:-1:-1;;;10166:68:2;;;;;;;:::i;:::-;-1:-1:-1;;;;;10245:18:2;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;;:36;;;10296:32;;;;;10275:6;;10296:32;:::i;:::-;;;;;;;;9965:370;;;:::o;7268:713::-;-1:-1:-1;;;;;7403:20:2;;7395:70;;;;-1:-1:-1;;;7395:70:2;;;;;;;:::i;:::-;-1:-1:-1;;;;;7483:23:2;;7475:71;;;;-1:-1:-1;;;7475:71:2;;;;;;;:::i;:::-;7557:47;7578:6;7586:9;7597:6;7557:20;:47::i;:::-;-1:-1:-1;;;;;7639:17:2;;7615:21;7639:17;;;;;;;;;;;7674:23;;;;7666:74;;;;-1:-1:-1;;;7666:74:2;;;;;;;:::i;:::-;-1:-1:-1;;;;;7774:17:2;;;:9;:17;;;;;;;;;;;7794:22;;;7774:42;;7836:20;;;;;;;;:30;;7810:6;;7774:9;7836:30;;7810:6;;7836:30;:::i;:::-;;;;;;;;7899:9;-1:-1:-1;;;;;7882:35:2;7891:6;-1:-1:-1;;;;;7882:35:2;;7910:6;7882:35;;;;;;:::i;:::-;;;;;;;;7928:46;7948:6;7956:9;7967:6;7928:19;:46::i;:::-;7268:713;;;;:::o;8257:389::-;-1:-1:-1;;;;;8340:21:2;;8332:65;;;;-1:-1:-1;;;8332:65:2;;;;;;;:::i;:::-;8408:49;8437:1;8441:7;8450:6;8408:20;:49::i;:::-;8484:6;8468:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;8500:18:2;;:9;:18;;;;;;;;;;:28;;8522:6;;8500:9;:28;;8522:6;;8500:28;:::i;:::-;;;;-1:-1:-1;;8543:37:2;;-1:-1:-1;;;;;8543:37:2;;;8560:1;;8543:37;;;;8573:6;;8543:37;:::i;:::-;;;;;;;;8591:48;8619:1;8623:7;8632:6;8591:19;:48::i;:::-;8257:389;;:::o;2034:169:3:-;2108:6;;;-1:-1:-1;;;;;2124:17:3;;;-1:-1:-1;;;;;;2124:17:3;;;;;;;2156:40;;2108:6;;;2124:17;2108:6;;2156:40;;2089:16;;2156:40;2034:169;;:::o;14:175:7:-;84:20;;-1:-1:-1;;;;;133:31:7;;123:42;;113:2;;179:1;176;169:12;194:198;;306:2;294:9;285:7;281:23;277:32;274:2;;;327:6;319;312:22;274:2;355:31;376:9;355:31;:::i;:::-;345:41;264:128;-1:-1:-1;;;264:128:7:o;397:274::-;;;526:2;514:9;505:7;501:23;497:32;494:2;;;547:6;539;532:22;494:2;575:31;596:9;575:31;:::i;:::-;565:41;;625:40;661:2;650:9;646:18;625:40;:::i;:::-;615:50;;484:187;;;;;:::o;676:342::-;;;;822:2;810:9;801:7;797:23;793:32;790:2;;;843:6;835;828:22;790:2;871:31;892:9;871:31;:::i;:::-;861:41;;921:40;957:2;946:9;942:18;921:40;:::i;:::-;911:50;;1008:2;997:9;993:18;980:32;970:42;;780:238;;;;;:::o;1023:266::-;;;1152:2;1140:9;1131:7;1127:23;1123:32;1120:2;;;1173:6;1165;1158:22;1120:2;1201:31;1222:9;1201:31;:::i;:::-;1191:41;1279:2;1264:18;;;;1251:32;;-1:-1:-1;;;1110:179:7:o;1294:203::-;-1:-1:-1;;;;;1458:32:7;;;;1440:51;;1428:2;1413:18;;1395:102::o;1502:187::-;1667:14;;1660:22;1642:41;;1630:2;1615:18;;1597:92::o;1694:603::-;;1835:2;1864;1853:9;1846:21;1896:6;1890:13;1939:6;1934:2;1923:9;1919:18;1912:34;1964:4;1977:140;1991:6;1988:1;1985:13;1977:140;;;2086:14;;;2082:23;;2076:30;2052:17;;;2071:2;2048:26;2041:66;2006:10;;1977:140;;;2135:6;2132:1;2129:13;2126:2;;;2205:4;2200:2;2191:6;2180:9;2176:22;2172:31;2165:45;2126:2;-1:-1:-1;2281:2:7;2260:15;-1:-1:-1;;2256:29:7;2241:45;;;;2288:2;2237:54;;1815:482;-1:-1:-1;;;1815:482:7:o;2302:399::-;2504:2;2486:21;;;2543:2;2523:18;;;2516:30;2582:34;2577:2;2562:18;;2555:62;-1:-1:-1;;;2648:2:7;2633:18;;2626:33;2691:3;2676:19;;2476:225::o;2706:402::-;2908:2;2890:21;;;2947:2;2927:18;;;2920:30;2986:34;2981:2;2966:18;;2959:62;-1:-1:-1;;;3052:2:7;3037:18;;3030:36;3098:3;3083:19;;2880:228::o;3113:398::-;3315:2;3297:21;;;3354:2;3334:18;;;3327:30;3393:34;3388:2;3373:18;;3366:62;-1:-1:-1;;;3459:2:7;3444:18;;3437:32;3501:3;3486:19;;3287:224::o;3516:402::-;3718:2;3700:21;;;3757:2;3737:18;;;3730:30;3796:34;3791:2;3776:18;;3769:62;-1:-1:-1;;;3862:2:7;3847:18;;3840:36;3908:3;3893:19;;3690:228::o;3923:404::-;4125:2;4107:21;;;4164:2;4144:18;;;4137:30;4203:34;4198:2;4183:18;;4176:62;-1:-1:-1;;;4269:2:7;4254:18;;4247:38;4317:3;4302:19;;4097:230::o;4332:356::-;4534:2;4516:21;;;4553:18;;;4546:30;4612:34;4607:2;4592:18;;4585:62;4679:2;4664:18;;4506:182::o;4693:401::-;4895:2;4877:21;;;4934:2;4914:18;;;4907:30;4973:34;4968:2;4953:18;;4946:62;-1:-1:-1;;;5039:2:7;5024:18;;5017:35;5084:3;5069:19;;4867:227::o;5099:400::-;5301:2;5283:21;;;5340:2;5320:18;;;5313:30;5379:34;5374:2;5359:18;;5352:62;-1:-1:-1;;;5445:2:7;5430:18;;5423:34;5489:3;5474:19;;5273:226::o;5504:401::-;5706:2;5688:21;;;5745:2;5725:18;;;5718:30;5784:34;5779:2;5764:18;;5757:62;-1:-1:-1;;;5850:2:7;5835:18;;5828:35;5895:3;5880:19;;5678:227::o;5910:355::-;6112:2;6094:21;;;6151:2;6131:18;;;6124:30;6190:33;6185:2;6170:18;;6163:61;6256:2;6241:18;;6084:181::o;6270:177::-;6416:25;;;6404:2;6389:18;;6371:76::o;6452:184::-;6624:4;6612:17;;;;6594:36;;6582:2;6567:18;;6549:87::o;6641:128::-;;6712:1;6708:6;6705:1;6702:13;6699:2;;;6718:18;;:::i;:::-;-1:-1:-1;6754:9:7;;6689:80::o;6774:125::-;;6842:1;6839;6836:8;6833:2;;;6847:18;;:::i;:::-;-1:-1:-1;6884:9:7;;6823:76::o;6904:380::-;6989:1;6979:12;;7036:1;7026:12;;;7047:2;;7101:4;7093:6;7089:17;7079:27;;7047:2;7154;7146:6;7143:14;7123:18;7120:38;7117:2;;;7200:10;7195:3;7191:20;7188:1;7181:31;7235:4;7232:1;7225:15;7263:4;7260:1;7253:15;7117:2;;6959:325;;;:::o;7289:127::-;7350:10;7345:3;7341:20;7338:1;7331:31;7381:4;7378:1;7371:15;7405:4;7402:1;7395:15","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[{"signature":"allowance(address,address)","signatureHash4":"0xdd62ed3e","signatureHash32":"0xdd62ed3e90e97b3d417db9c0c7522647811bafca5afc6694f143588d255fdfb4"},{"signature":"approve(address,uint256)","signatureHash4":"0x095ea7b3","signatureHash32":"0x095ea7b334ae44009aa867bfb386f5c3b4b443ac6f0ee573fa91c4608fbadfba"},{"signature":"balanceOf(address)","signatureHash4":"0x70a08231","signatureHash32":"0x70a08231b98ef4ca268c9cc3f6b4590e4bfec28280db06bb5d45e689f2a360be"},{"signature":"decimals()","signatureHash4":"0x313ce567","signatureHash32":"0x313ce567add4d438edf58b94ff345d7d38c45b17dfc0f947988d7819dca364f9"},{"signature":"decreaseAllowance(address,uint256)","signatureHash4":"0xa457c2d7","signatureHash32":"0xa457c2d77307f80ff2f3ac810ec99eb18ae2cffee13b29c90c9324546e374be5"},{"signature":"increaseAllowance(address,uint256)","signatureHash4":"0x39509351","signatureHash32":"0x39509351d3325647dde3fdd3c8b249adfe89ef4f16d76d83768e6df7a5cd81d6"},{"signature":"MAX_SUPPLY()","signatureHash4":"0x32cb6b0c","signatureHash32":"0x32cb6b0c9d125b1472513cbeeb7f75e981364c137d7d7140f52eb5e4e9cbb979"},{"signature":"mint(address,uint256)","signatureHash4":"0x40c10f19","signatureHash32":"0x40c10f19c047ae7dfa66d6312b683d2ea3dfbcb4159e96b967c5f4b0a86f2842"},{"signature":"name()","signatureHash4":"0x06fdde03","signatureHash32":"0x06fdde0383f15d582d1a74511486c9ddf862a882fb7904b3d9fe9b8b8e58a796"},{"signature":"owner()","signatureHash4":"0x8da5cb5b","signatureHash32":"0x8da5cb5b36e7f68c1d2e56001220cdbdd3ba2616072f718acfda4a06441a807d"},{"signature":"renounceOwnership()","signatureHash4":"0x715018a6","signatureHash32":"0x715018a616b5f2044428f6fadb7deef4ce9ca76ef60ea57978964ad137bbe7ae"},{"signature":"symbol()","signatureHash4":"0x95d89b41","signatureHash32":"0x95d89b41e2f5f391a79ec54e9d87c79d6e777c63e32c28da95b4e9e4a79250ec"},{"signature":"totalSupply()","signatureHash4":"0x18160ddd","signatureHash32":"0x18160ddd7f15c72528c2f94fd8dfe3c8d5aa26e2c50c7d81f4bc7bee8d4b7932"},{"signature":"transfer(address,uint256)","signatureHash4":"0xa9059cbb","signatureHash32":"0xa9059cbb2ab09eb219583f4a59a5d0623ade346d962bcd4e46b11da047c9049b"},{"signature":"transferFrom(address,address,uint256)","signatureHash4":"0x23b872dd","signatureHash32":"0x23b872dd7302113369cda2901243429419bec145408fa8b352b3dd92b66c680b"},{"signature":"transferOwnership(address)","signatureHash4":"0xf2fde38b","signatureHash32":"0xf2fde38b092330466c661fc723d5289b90272a3e580e3187d1d7ef788506c557"}],"event":[{"signature":"Approval(address,address,uint256)","signatureHash4":"0x8c5be1e5","signatureHash32":"0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925"},{"signature":"OwnershipTransferred(address,address)","signatureHash4":"0x8be0079c","signatureHash32":"0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0"},{"signature":"Transfer(address,address,uint256)","signatureHash4":"0xddf252ad","signatureHash32":"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"}],"error":[]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"56","address":"0xcf3232B85b43BCa90E51D38cc06Cc8bB8C8A3E36"}