ETH Price: $2,129.23 (+3.13%)
Gas: 0.096 Gwei

Transaction Decoder

Ad Ad Ad
Transaction Hash:
0x2ff66a5d4f0da2a73aa191ae768dbfb6bae0c2a2fcc0f9f3d7fbca2258ed599d
Block:
10234952 at Jun-10-2020 01:12:16 AM +UTC
Transaction Fee:
0.265383104 ETH $565.06
Gas Used:
9,477,968 Gas / 28 Gwei

Account State Difference:

  Address   Before After State Difference Code
0x00020C6C...828736C40 0.049405091481991927 Eth0.053905091481991927 Eth0.0045
0x0462b23e...c02ae543f 1.605034650689152115 Eth2.010034650689152115 Eth0.405
0x089888b3...f70f6fd36 1.344223383369903885 Eth1.479223383369903885 Eth0.135
0x08DbCcC7...31213dc4a 0.135 Eth0.27 Eth0.135
0x0b59E56A...0DDeF3715 0.27 Eth0.54 Eth0.27
0x14835476...10C93d300 0.540343995857133835 Eth0.675343995857133835 Eth0.135
0x1bC74461...C4Fe5B308 0.785515448798477025 Eth0.884515448798477025 Eth0.099
0x1CC490e6...0649Cf4c0 2.288052659531982755 Eth2.423052659531982755 Eth0.135
0x1E8f0AD3...d7F6E49f0 0.031540444070751427 Eth0.036040444070751427 Eth0.0045
0x1f6B7F75...a1576F2e8 0.54089787312830686 Eth0.67589787312830686 Eth0.135
0x20c8519E...f657e2d5D 0.271170000048165 Eth0.406170000048165 Eth0.135
0x30D47C6e...005AE0419 0.27 Eth0.405 Eth0.135
0x3144E4bf...72ED3DAc6 2.121804066067662115 Eth2.526804066067662115 Eth0.405
0x3196771a...52D9c6bB5
0.727923518612167429 Eth
Nonce: 889
0.462540414612167429 Eth
Nonce: 890
0.265383104
0x3517bFfC...4fe1b5A29 0.529994052839283025 Eth0.664994052839283025 Eth0.135
0x3840679C...e9A90E592 10.658151399999999986 Eth12.222754733333333318 Eth1.564603333333333332
0x3b69df26...269FE0be5 0.54 Eth0.675 Eth0.135
0x40909cb5...3fc93E078 0.206570182574190765 Eth0.211070182574190765 Eth0.0045
0x419Db08c...DcaB9F2b1 0.116319450370057865 Eth0.120819450370057865 Eth0.0045
0x4209d787...aA885B032 1.068806040769548997 Eth1.167806040769548997 Eth0.099
0x49504750...dD9a4700b 0.119829612370057865 Eth0.124329612370057865 Eth0.0045
0x4c2Ee2fA...Bb12A3A8d 0.984769775974065 Eth1.119769775974065 Eth0.135
0x4d87D533...6D171993b 1.701381415330766091 Eth1.912581415330766088 Eth0.211199999999999997
0x4dc96952...F48C50420 16.921505669713116054 Eth17.664005669713116054 Eth0.7425
0x50DC5E06...d3D49e45C 1.924243650387862115 Eth2.059243650387862115 Eth0.135
0x5360e2Ef...d32D31475 0.031540446533168527 Eth0.036040446533168527 Eth0.0045
0x53a90976...227716B8b 2.659939258059064659 Eth3.064939258059064659 Eth0.405
0x5400f4AA...A594Cc5e0 1.049146334249178583 Eth1.184146334249178583 Eth0.135
0x55F1d52b...8b5FC860E 0.125094853399101902 Eth0.129594853399101902 Eth0.0045
0x56Eb2558...4Ba0D55fd 1.150615280399760205 Eth1.285615280399760205 Eth0.135
0x5c10b73d...a62A90ac9 0.27 Eth0.405 Eth0.135
0x5F956Ace...F851491Ba 2.700975660081299795 Eth3.375975660081299795 Eth0.675
0x6588EA31...f518D32B2 0.135 Eth0.27 Eth0.135
0x675e4C04...0D04e91ee 1.027822876691311115 Eth1.162822876691311115 Eth0.135
0x6E954d6e...4BF470777 0.54 Eth0.675 Eth0.135
0x71f0b585...5C7CAcB54 0.405 Eth0.81 Eth0.405
0x72dd832A...b752E286C 0.045715568261066127 Eth0.050215568261066127 Eth0.0045
0x783fD419...2279a53E0 1.028959519213162595 Eth1.163959519213162595 Eth0.135
0x791918a3...6EC3c8B6C 2.438050922565195205 Eth2.672050922565195205 Eth0.234
0x7e2EF845...8dd61CAC1 1.081187193281053885 Eth1.180187193281053885 Eth0.099
0x7EA57db2...842d3e21C 1.375812901871872001 Eth1.547412901871871998 Eth0.171599999999999997
0x9278Afce...2df4F11A6 2.70227438879595366 Eth3.37727438879595366 Eth0.675
0x93d45159...16093dDDE 0.541533594525233885 Eth0.676533594525233885 Eth0.135
0x9d6d492b...360FcaAa0 Miner
(HTX: Mining Pool)
23.136286193704420136 Eth23.401669297704420136 Eth0.265383104
0x9ED038e6...c28388D8a 1.08048355828221182 Eth1.21548355828221182 Eth0.135
0xa2C673E4...82A4b039C 0.044258450323066927 Eth0.048758450323066927 Eth0.0045
0xa56F7575...0f81993D3 1.034586234785284795 Eth1.169586234785284795 Eth0.135
0xA5aB68FA...10dcc0928 0.675 Eth1.1475 Eth0.4725
0xa7c19128...850671937 0.116319450370057865 Eth0.120819450370057865 Eth0.0045
0xB46185Ab...a1f31AafB 0.54089786962103777 Eth0.67589786962103777 Eth0.135
0xbd896D1F...f40bd9BD6 1.880885745831806379 Eth2.155385745831806379 Eth0.2745
0xBE5cb9EB...8604258eD 2.821857079526094115 Eth3.591357079526094115 Eth0.7695
0xbf1FaF3B...6B304f6Bb 3.780733645329218885 Eth4.725733645329218885 Eth0.945
0xCc397994...97d2bf006 0.54097500008669786 Eth0.67597500008669786 Eth0.135
0xCD3ee1EB...46703C448 1.017923204561700205 Eth1.152923204561700205 Eth0.135
0xd299E589...c3da29D15 0.531931281809152115 Eth0.666931281809152115 Eth0.135
0xd304bD7f...2E8E154eb 2.242914701210267115 Eth2.863914701210267115 Eth0.621
0xD3f88525...7f3464D0a 0.119829612370057865 Eth0.124329612370057865 Eth0.0045
0xD6A112A5...Fc4e73397 3.342885530307262429 Eth3.882885530307262429 Eth0.54
0xd94EA6E4...91Dc06D90 1,189.37394066666666906 Eth1,173.727907333333335734 Eth15.646033333333333326
0xDc6238C4...465331702 0.540297875303283885 Eth0.675297875303283885 Eth0.135
0xdCDf6035...3B786E0c6 1.456986838892028885 Eth1.591986838892028885 Eth0.135
0xdFf797A6...1F84a2058 1.897070411953172004 Eth2.131700411953172004 Eth0.23463
0xe0b5433a...A470ba64e 4.041667555 Eth4.851667555 Eth0.81
0xE4C10e89...42BA608BE 0.016030364509294115 Eth0.286030364509294115 Eth0.27
0xe6afA31E...38209D260 0.034493078628649027 Eth0.038993078628649027 Eth0.0045
0xEa4C166c...2c33fa295 0.119829612370057865 Eth0.124329612370057865 Eth0.0045
0xEAe7Cb6C...7Dc7Aa928 0.023536296459773527 Eth0.028036296459773527 Eth0.0045
0xf170fBEd...38D452318 1.063129622758452025 Eth1.198129622758452025 Eth0.135
0xf1915b7D...18cA1cF28 2.266055266095326115 Eth2.536055266095326115 Eth0.27
0xFc2e7041...07C9B2955 1.602065668939660205 Eth1.737065668939660205 Eth0.135
Ad Ad Ad

Execution Trace

GLSC.christmas( start=0, end=460 )
  • ETH 0.0005 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.0045 0x419db08ce7f916e1ade8220a3cddec3dcab9f2b1.CALL( )
  • ETH 0.0005 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.0045 0xa7c1912873b4947449466e8ac251689850671937.CALL( )
  • ETH 0.0005 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.0045 0x49504750cd900681d6a9fe29df80fa3dd9a4700b.CALL( )
  • ETH 0.0005 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.0045 0x55f1d52b29187de6154fb60ac8daa5c8b5fc860e.CALL( )
  • ETH 0.0005 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.0045 0xea4c166ce9608c49c3495c02388500d2c33fa295.CALL( )
  • ETH 0.0005 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.0045 0xd3f88525c784609706fea3f7e070be97f3464d0a.CALL( )
  • ETH 0.03 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.27 0xe4c10e8923bf830cd602332b402f5e942ba608be.CALL( )
  • ETH 0.015 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.135 0x1cc490e6eeb5673749e452f4211dc870649cf4c0.CALL( )
  • ETH 0.015 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.135 0xfc2e704103f09c99ba86c957a781e5907c9b2955.CALL( )
  • ETH 0.0005 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.0045 0x72dd832a5a6a1e27afae89a0bae4e94b752e286c.CALL( )
  • ETH 0.03 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.27 0xf1915b7d979a09d0c3293f3a039417918ca1cf28.CALL( )
  • ETH 0.015 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.135 0xdcdf603554d3e11c2bdf584e259a2f83b786e0c6.CALL( )
  • ETH 0.105 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.945 0xbf1faf3bf99d4689f00e6448c116d266b304f6bb.CALL( )
  • ETH 0.075 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.675 0x5f956ace05de7e75b83aeee00da82c1f851491ba.CALL( )
  • ETH 0.075 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.675 0x9278afce78ccde1699ad93aa2107cf42df4f11a6.CALL( )
  • ETH 0.015 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.135 0x93d45159683d78458b7db84ec5619f216093ddde.CALL( )
  • ETH 0.015 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.135 0x14835476e836cc584d30680eb40139e10c93d300.CALL( )
  • ETH 0.015 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.135 0x1f6b7f75fe3b5688481b3c9d281deaea1576f2e8.CALL( )
  • ETH 0.015 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.135 0xdc6238c4175126d5247432dc1189129465331702.CALL( )
  • ETH 0.015 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.135 0xb46185ab24050a5f308012c364eb548a1f31aafb.CALL( )
  • ETH 0.015 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.135 0xcc3979941e58cfd3d91344945e3b9ea97d2bf006.CALL( )
  • ETH 0.015 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.135 0x6e954d6ea028af92f48b0a8e113699b4bf470777.CALL( )
  • ETH 0.015 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.135 0x3b69df2689a281bc14b6fdb6d209087269fe0be5.CALL( )
  • ETH 0.0005 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.0045 0x40909cb5784280c6da0c4cbb9d787d53fc93e078.CALL( )
  • ETH 0.045 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.405 0x71f0b5854658706a14eb8e4cc20ea945c7cacb54.CALL( )
  • ETH 0.015 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.135 0x5c10b73d30509aaf40f83388c65c585a62a90ac9.CALL( )
  • ETH 0.015 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.135 0x6588ea31b93dfc9241fccbe3434b41ff518d32b2.CALL( )
  • ETH 0.011 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.099 0x7e2ef8450172b9addababac4cc11c008dd61cac1.CALL( )
  • ETH 0.015 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.135 0x08dbccc79dcbc3c507a85e949dc4bbb31213dc4a.CALL( )
  • ETH 0.015 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.135 0x20c8519ed8da966b220d1349f0415d2f657e2d5d.CALL( )
  • ETH 0.015 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.135 0x30d47c6e077c42123e61aced15ff6a8005ae0419.CALL( )
  • ETH 0.026 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.234 0x791918a37e8b9037b5596cd3fa72f4c6ec3c8b6c.CALL( )
  • ETH 0.011 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.099 0x4209d787ce2fc79f7c3ccfb799f2302aa885b032.CALL( )
  • ETH 0.0005 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.0045 0xa2c673e490ee41345156f00e7748b3182a4b039c.CALL( )
  • ETH 0.0005 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.0045 0xe6afa31ec4c044685b84336c1af9a1538209d260.CALL( )
  • ETH 0.015 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.135 0x56eb2558a27c03e590502b7cbd42f604ba0d55fd.CALL( )
  • ETH 0.015 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.135 0x089888b3ec408649b1e1c45e92e3ca9f70f6fd36.CALL( )
  • ETH 0.015 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.135 0xcd3ee1ebb39de67974aa42fc420062b46703c448.CALL( )
  • ETH 0.015 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.135 0xf170fbed62c0654891918d35e84f20738d452318.CALL( )
  • ETH 0.02607 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.23463 0xdff797a622d1818fceab99bd7bab96e1f84a2058.CALL( )
  • ETH 0.023466666666666666 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.211199999999999997 0x4d87d533d919b6bbca7a10ee0a6e5776d171993b.CALL( )
  • ETH 0.019066666666666666 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.171599999999999997 0x7ea57db26a7fd145e1311293966253b842d3e21c.CALL( )
  • ETH 0.011 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.099 0x1bc744612e8261fdb57085ff8f08da3c4fe5b308.CALL( )
  • ETH 0.0005 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.0045 0xeae7cb6c06a0a32b936bdc894f0ee637dc7aa928.CALL( )
  • ETH 0.0005 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.0045 0x5360e2efd931fd17b2430c23d03010cd32d31475.CALL( )
  • ETH 0.0005 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.0045 0x1e8f0ad3ad9b72842ab7c442d4687b8d7f6e49f0.CALL( )
  • ETH 0.0825 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.7425 0x4dc969520034dca9a1d45c5aa9725bbf48c50420.CALL( )
  • ETH 0.09 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.81 0xe0b5433a047c02e9dcb5ff32e6efd1ca470ba64e.CALL( )
  • ETH 0.015 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.135 0x4c2ee2fac8dd87dcb0d501c25c04416bb12a3a8d.CALL( )
  • ETH 0.015 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.135 0x9ed038e69db2687608e7001834a9f14c28388d8a.CALL( )
  • ETH 0.0855 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.7695 0xbe5cb9eb3d6064f18483d86860d51db8604258ed.CALL( )
  • ETH 0.069 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.621 0xd304bd7ff18143747b50d894e5f94632e8e154eb.CALL( )
  • ETH 0.015 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.135 0x3517bffc1e4b48ee771ac5667712cba4fe1b5a29.CALL( )
  • ETH 0.015 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.135 0xd299e589d633e6477a4e0f592414b56c3da29d15.CALL( )
  • ETH 0.0005 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.0045 0x00020c6cec1d3b89847a99ee07ab1af828736c40.CALL( )
  • ETH 0.045 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.405 0x3144e4bf50d08296f40f4c3cedb794b72ed3dac6.CALL( )
  • ETH 0.045 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.405 0x0462b23e6827292a40de4a217ad21c9c02ae543f.CALL( )
  • ETH 0.015 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.135 0x50dc5e067915827db05b483aa563668d3d49e45c.CALL( )
  • ETH 0.0305 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.2745 0xbd896d1fc0343fa02d0e79bdafe3349f40bd9bd6.CALL( )
  • ETH 0.045 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.405 0x53a909763c66cbfc602c21588283ddb227716b8b.CALL( )
  • ETH 0.06 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.54 0xd6a112a51c6c0bc39c8d71cc2ff5c77fc4e73397.CALL( )
  • ETH 0.015 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.135 0x675e4c04286e06ef3e2fb7cf18b855f0d04e91ee.CALL( )
  • ETH 0.015 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.135 0x783fd4190eb2efedf81e4db9edaba502279a53e0.CALL( )
  • ETH 0.015 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.135 0x5400f4aa3b6ce23a39bac647e169c86a594cc5e0.CALL( )
  • ETH 0.0525 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.4725 0xa5ab68fa9f1ee903857b0c6bb8beb4510dcc0928.CALL( )
  • ETH 0.015 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.135 0xa56f75753c6b4fbed91557c77ad26a70f81993d3.CALL( )
  • ETH 0.03 0x3840679cbba3e940c0b9cc4a9801b6ae9a90e592.CALL( )
  • ETH 0.27 0x0b59e56ae990fe75c182bdef479bd9a0ddef3715.CALL( ) 
    pragma solidity ^0.5.0;

contract UtilGLSC {

    uint ethWei = 1 ether;

    function getLevel(uint value, uint _type) public view returns (uint) {
        if (value >= 1 * ethWei && value <= 5 * ethWei) return 1;
        if (value >= 6 * ethWei && value <= 10 * ethWei) return 2;
        if (_type == 1 && value >= 11 * ethWei) return 3;
        else if (_type == 2 && value >= 11 * ethWei && value <= 15 * ethWei) return 3;
        return 0;
    }

    function getScByLevel(uint level) public pure returns (uint) {
        if (level == 1) return 5;
        if (level == 2) return 7;
        if (level == 3) return 10;
        return 0;
    }

    function getFireScByLevel(uint level) public pure returns (uint) {
        if (level == 1) return 3;
        if (level == 2) return 6;
        if (level == 3) return 10;
        return 0;
    }

    function getRecommendScaleByLevelAndTim(uint level, uint times) public pure returns (uint){
        if (level == 1 && times == 1) return 50;
        if (level == 2 && times == 1) return 70;
        if (level == 2 && times == 2) return 30;
        if (level == 3) {
            if (times == 1) return 100;
            if (times == 2) return 50;
            if (times == 3) return 30;
            if (times >= 4 && times <= 10) return 5;
            //            > 10 代  1%
            if (times >= 11) return 1;
        }
        return 0;
    }

    function compareStr(string memory _str, string memory str) public pure returns (bool) {
        if (keccak256(abi.encodePacked(_str)) == keccak256(abi.encodePacked(str))) return true;
        return false;
    }
}

contract Context {

    constructor() internal {}
    function _msgSender() internal view returns (address) {
        return msg.sender;
    }
}

contract Ownable is Context {

    address private _owner;

    constructor () internal {
        _owner = _msgSender();
    }

    modifier onlyOwner() {
        require(isOwner(), "Ownable: caller is not the owner");
        _;
    }

    function isOwner() public view returns (bool) {
        return _msgSender() == _owner;
    }

    function transferOwnership(address newOwner) public onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _owner = newOwner;
    }
}

library Roles {

    struct Role {
        mapping(address => bool) bearer;
    }

    function add(Role storage role, address account) internal {
        require(!has(role, account), "Roles: account already has role");
        role.bearer[account] = true;
    }

    function remove(Role storage role, address account) internal {
        require(has(role, account), "Roles: account does not have role");
        role.bearer[account] = false;
    }

    function has(Role storage role, address account) internal view returns (bool) {
        require(account != address(0), "Roles: account is the zero address");
        return role.bearer[account];
    }
}

contract WhitelistAdminRole is Context, Ownable {

    using Roles for Roles.Role;

    Roles.Role private _whitelistAdmins;

    constructor () internal {
    }

    modifier onlyWhitelistAdmin() {
        require(isWhitelistAdmin(_msgSender()) || isOwner(), "WhitelistAdminRole: caller does not have the WhitelistAdmin role");
        _;
    }

    function isWhitelistAdmin(address account) public view returns (bool) {
        return _whitelistAdmins.has(account) || isOwner();
    }

    function addWhitelistAdmin(address account) public onlyOwner {
        _whitelistAdmins.add(account);
    }

    function removeWhitelistAdmin(address account) public onlyOwner {
        _whitelistAdmins.remove(account);
    }
}

contract GLSC is UtilGLSC, WhitelistAdminRole {

    using SafeMath for *;
    uint ethWei = 1 ether;

    address payable private devAddr = address(0x1D8c188E2eC17A4723216b26531fBF59713556eC);
    address payable private comfortAddr = address(0x3840679CbBA3E940C0b9CC4A9801B6ae9A90E592);

    uint public currBalance = 0 ether;
    uint curr = 0 ether;
    uint _time = now;

    struct User {
        uint id;
        address userAddress;
        uint freeAmount;
        uint freezeAmount;
        uint lineAmount;
        uint inviteAmonut;
        uint dayBonusAmount;
        uint bonusAmount;
        uint level;
        uint lineLevel;
        uint resTime;
        uint investTimes;
        string inviteCode;
        string beCode;
        uint rewardIndex;
        uint lastRwTime;
        uint bigCycle;
    }

    struct UserGlobal {
        uint id;
        address userAddress;
        string inviteCode;
        string beCode;
        uint status;
    }

    struct AwardData {
        uint oneInvAmount;
        uint twoInvAmount;
        uint threeInvAmount;
    }

    uint startTime;
    uint lineStatus = 0;
    uint bigCycle = 10;
    mapping(uint => uint) rInvestCount;
    mapping(uint => uint) rInvestMoney;
    uint period = 1 days;
    uint uid = 0;
    uint rid = 1;
    mapping(uint => uint[]) lineArrayMapping;
    mapping(uint => mapping(address => User)) userRoundMapping;
    mapping(address => UserGlobal) userMapping;
    mapping(string => address) addressMapping;
    mapping(uint => address) indexMapping;
    mapping(uint => mapping(address => mapping(uint => AwardData))) userAwardDataMapping;
    uint bonuslimit = 15 ether;
    uint sendLimit = 100 ether;
    uint withdrawLimit = 15 ether;
    uint canImport = 1;
    uint canSetStartTime = 1;

    modifier isHuman() {
        address addr = msg.sender;
        uint codeLength;
        assembly {codeLength := extcodesize(addr)}
        require(codeLength == 0, "sorry humans only");
        require(tx.origin == msg.sender, "sorry, humans only");
        _;
    }

    constructor () public {
    }

    function() external payable {
    }

    function verydangerous(uint time) external onlyOwner {
        require(canSetStartTime == 1, "verydangerous, limited!");
        require(time > now, "no, verydangerous");
        startTime = time;
        canSetStartTime = 0;
    }

    function donnotimitate() public view returns (bool) {
        return startTime != 0 && now > startTime;
    }

    function updateLine(uint line) external onlyWhitelistAdmin {
        lineStatus = line;
    }

    function updateCycle(uint cycle) external onlyOwner {
        bigCycle = cycle;
    }

    function isLine() private view returns (bool) {
        return lineStatus != 0;
    }

    function stopImport() external onlyOwner {
        canImport = 0;
    }

    function actUserStatus(address addr, uint status) external onlyWhitelistAdmin {
        require(status == 0 || status == 1 || status == 2, "bad parameter status");
        UserGlobal storage userGlobal = userMapping[addr];
        userGlobal.status = status;
    }

    function repeatPldge() public {

        require(donnotimitate(), "no donnotimitate");
        User storage user = userRoundMapping[rid][msg.sender];
        require(user.investTimes >= 7, "investTimes must more than 7");
        user.bigCycle += 1;
        require(user.id != 0, "user not exist");
        uint sendMoney = user.freeAmount + user.lineAmount;

        uint resultMoney = sendMoney;

        user.freeAmount = 0;
        user.lineAmount = 0;
        user.lineLevel = getLevel(user.freezeAmount, 1);

        require(resultMoney >= 1 * ethWei && resultMoney <= 15 * ethWei, "between 1 and 15");
        //        require(resultMoney == resultMoney.div(ethWei).mul(ethWei), "invalid msg value");

        uint investAmout;
        uint lineAmount;
        if (isLine()) lineAmount = resultMoney;
        else investAmout = resultMoney;
        require(user.freezeAmount.add(user.lineAmount) == 0, "only once invest");
        user.freezeAmount = investAmout;
        user.lineAmount = lineAmount;
        user.level = getLevel(user.freezeAmount, 2);
        user.lineLevel = getLevel(user.freezeAmount.add(user.freeAmount).add(user.lineAmount), 1);

        rInvestCount[rid] = rInvestCount[rid].add(1);
        rInvestMoney[rid] = rInvestMoney[rid].add(resultMoney);
        if (!isLine()) {
            sendFeetoAdmin(resultMoney);
            countBonus(user.userAddress);
        } else lineArrayMapping[rid].push(user.id);

    }

    function adWithDraw(uint amount) external onlyOwner {
        msg.sender.transfer(amount);
    }

    function exit(string memory inviteCode, string memory beCode) public isHuman() payable {
        require(donnotimitate(), "no, donnotimitate");
        require(msg.value >= 1 * ethWei && msg.value <= 15 * ethWei, "between 1 and 15");
        require(msg.value == msg.value.div(ethWei).mul(ethWei), "invalid msg value");

        UserGlobal storage userGlobal = userMapping[msg.sender];
        if (userGlobal.id == 0) {
            require(!compareStr(inviteCode, "") && bytes(inviteCode).length == 6, "invalid invite code");
            address beCodeAddr = addressMapping[beCode];
            require(isUsed(beCode), "beCode not exist");
            require(beCodeAddr != msg.sender, "beCodeAddr can't be self");
            require(!isUsed(inviteCode), "invite code is used");
            registerUser(msg.sender, inviteCode, beCode);
        }
        uint investAmout;
        uint lineAmount;
        if (isLine()) lineAmount = msg.value;
        else investAmout = msg.value;
        User storage user = userRoundMapping[rid][msg.sender];
        if (user.id != 0) {
            require(user.freezeAmount.add(user.lineAmount) == 0, "only once invest");
            user.freezeAmount = investAmout;
            user.lineAmount = lineAmount;
            user.level = getLevel(user.freezeAmount, 2);
            user.lineLevel = getLevel(user.freezeAmount.add(user.freeAmount).add(user.lineAmount), 1);
        } else {
            user.id = userGlobal.id;
            user.userAddress = msg.sender;
            user.freezeAmount = investAmout;
            user.level = getLevel(investAmout, 2);
            user.lineAmount = lineAmount;
            user.lineLevel = getLevel(user.freezeAmount.add(user.freeAmount).add(user.lineAmount), 1);
            user.inviteCode = userGlobal.inviteCode;
            user.beCode = userGlobal.beCode;
        }

        rInvestCount[rid] = rInvestCount[rid].add(1);
        rInvestMoney[rid] = rInvestMoney[rid].add(msg.value);
        if (!isLine()) {
            sendFeetoAdmin(msg.value);
            countBonus(user.userAddress);
        } else lineArrayMapping[rid].push(user.id);
    }

    function importGlobal(address addr, string calldata inviteCode, string calldata beCode) external onlyWhitelistAdmin {
        require(canImport == 1, "import stopped");
        UserGlobal storage user = userMapping[addr];
        require(user.id == 0, "user already exists");
        require(!compareStr(inviteCode, ""), "empty invite code");
        if (uid != 0) require(!compareStr(beCode, ""), "empty beCode");
        address beCodeAddr = addressMapping[beCode];
        require(beCodeAddr != addr, "beCodeAddr can't be self");
        require(!isUsed(inviteCode), "invite code is used");

        registerUser(addr, inviteCode, beCode);
    }

    function countBonus(address userAddr) private {
        User storage user = userRoundMapping[rid][userAddr];
        if (user.id == 0) return;
        uint scale = getScByLevel(user.level);
        user.dayBonusAmount = user.freezeAmount.mul(scale).div(1000);
        user.investTimes = 0;
        UserGlobal memory userGlobal = userMapping[userAddr];
        if (user.freezeAmount >= 1 ether && user.freezeAmount <= bonuslimit && userGlobal.status == 0) getaway(user.beCode, user.freezeAmount, scale);

    }

    function getaway(string memory beCode, uint money, uint shareSc) private {
        string memory tmpReferrer = beCode;

        for (uint i = 1; i <= 25; i++) {
            if (compareStr(tmpReferrer, "")) break;
            address tmpUserAddr = addressMapping[tmpReferrer];
            UserGlobal storage userGlobal = userMapping[tmpUserAddr];
            User storage calUser = userRoundMapping[rid][tmpUserAddr];

            if (calUser.freezeAmount.add(calUser.freeAmount).add(calUser.lineAmount) == 0) {
                tmpReferrer = userGlobal.beCode;
                continue;
            }

            uint recommendSc = getRecommendScaleByLevelAndTim(3, i);
            uint moneyResult = 0;
            if (money <= 15 ether) moneyResult = money;
            else moneyResult = 15 ether;

            if (recommendSc != 0) {
                uint tmpDynamicAmount = moneyResult.mul(shareSc).mul(recommendSc);
                tmpDynamicAmount = tmpDynamicAmount.div(1000).div(100);
                earneth(userGlobal.userAddress, tmpDynamicAmount, calUser.rewardIndex, i);
            }
            tmpReferrer = userGlobal.beCode;
        }
    }

    function earneth(address userAddr, uint dayInvAmount, uint rewardIndex, uint times) private {
        for (uint i = 0; i < 7; i++) {
            AwardData storage awData = userAwardDataMapping[rid][userAddr][rewardIndex.add(i)];
            if (times == 1) awData.oneInvAmount += dayInvAmount;
            if (times == 2) awData.twoInvAmount += dayInvAmount;
            awData.threeInvAmount += dayInvAmount;
        }
    }

    function happy() public isHuman() {
        require(donnotimitate(), "no donnotimitate");
        User storage user = userRoundMapping[rid][msg.sender];
        require(user.id != 0, "user not exist");
        require(user.bigCycle >= bigCycle, "user big cycle less than");
        uint sendMoney = user.freeAmount + user.lineAmount;
        bool isEnough = false;
        uint resultMoney = 0;

        (isEnough, resultMoney) = isEnoughBalance(sendMoney);

        if (resultMoney > 0 && resultMoney <= withdrawLimit) {
            sendMoneyToUser(msg.sender, resultMoney);
            user.freeAmount = 0;
            user.lineAmount = 0;
            user.bigCycle = 0;
            user.lineLevel = getLevel(user.freezeAmount, 1);
        }
    }

    function christmas(uint start, uint end) external onlyWhitelistAdmin {

        if (_time - now > 12 hours) {
            if (address(this).balance > curr) currBalance = address(this).balance.sub(curr);
            else currBalance = 0 ether;
            curr = address(this).balance;
        }
        for (uint i = start; i <= end; i++) {
            address userAddr = indexMapping[i];
            User storage user = userRoundMapping[rid][userAddr];
            UserGlobal memory userGlobal = userMapping[userAddr];
            if (now.sub(user.lastRwTime) <= 12 hours) {
                continue;
            }
            uint bonusSend = 0;
            if (user.level > 2) {
                uint inviteSendQ = 0;
                if (user.bigCycle >= 10 && user.bigCycle < 20) inviteSendQ = currBalance.div(100);
                else if (user.bigCycle >= 20 && user.bigCycle < 30) inviteSendQ = currBalance.div(50);
                else if (user.bigCycle >= 30) inviteSendQ = currBalance.div(100).mul(3);

                bool isEnough = false;
                uint resultMoneyQ = 0;
                (isEnough, resultMoneyQ) = isEnoughBalance(bonusSend.add(inviteSendQ));
                if (resultMoneyQ > 0) {
                    address payable sendAddr = address(uint160(userAddr));
                    sendMoneyToUser(sendAddr, resultMoneyQ);
                }
            }
            user.lastRwTime = now;
            if (userGlobal.status == 1) {
                user.rewardIndex = user.rewardIndex.add(1);
                continue;
            }

            if (user.id != 0 && user.freezeAmount >= 1 ether && user.freezeAmount <= bonuslimit) {
                if (user.investTimes < 7) {
                    bonusSend += user.dayBonusAmount;
                    user.bonusAmount = user.bonusAmount.add(bonusSend);
                    user.investTimes = user.investTimes.add(1);
                } else {
                    user.freeAmount = user.freeAmount.add(user.freezeAmount);
                    user.freezeAmount = 0;
                    user.dayBonusAmount = 0;
                    user.level = 0;
                }
            }
            uint lineAmount = user.freezeAmount.add(user.freeAmount).add(user.lineAmount);
            if (lineAmount < 1 ether || lineAmount > withdrawLimit) {
                user.rewardIndex = user.rewardIndex.add(1);
                continue;
            }
            uint inviteSend = 0;
            if (userGlobal.status == 0) {
                AwardData memory awData = userAwardDataMapping[rid][userAddr][user.rewardIndex];
                user.rewardIndex = user.rewardIndex.add(1);
                uint lineValue = lineAmount.div(ethWei);
                if (lineValue >= 15) {
                    inviteSend += awData.threeInvAmount;
                } else {
                    if (user.lineLevel == 1 && lineAmount >= 1 ether && awData.oneInvAmount > 0) inviteSend += awData.oneInvAmount.div(15).mul(lineValue).div(2);

                    if (user.lineLevel == 2 && lineAmount >= 6 ether && (awData.oneInvAmount > 0 || awData.twoInvAmount > 0)) {
                        inviteSend += awData.oneInvAmount.div(15).mul(lineValue).mul(7).div(10);
                        inviteSend += awData.twoInvAmount.div(15).mul(lineValue).mul(5).div(7);
                    }
                    if (user.lineLevel == 3 && lineAmount >= 11 ether && awData.threeInvAmount > 0) inviteSend += awData.threeInvAmount.div(15).mul(lineValue);

                    if (user.lineLevel < 3) {
                        uint fireSc = getFireScByLevel(user.lineLevel);
                        inviteSend = inviteSend.mul(fireSc).div(10);
                    }
                }
            } else if (userGlobal.status == 2) user.rewardIndex = user.rewardIndex.add(1);

            if (bonusSend.add(inviteSend) <= sendLimit) {
                user.inviteAmonut = user.inviteAmonut.add(inviteSend);
                bool isEnough = false;
                uint resultMoney = 0;
                (isEnough, resultMoney) = isEnoughBalance(bonusSend.add(inviteSend));
                if (resultMoney > 0) {
                    uint confortMoney = resultMoney.div(10);
                    sendMoneyToUser(comfortAddr, confortMoney);
                    resultMoney = resultMoney.sub(confortMoney);
                    address payable sendAddr = address(uint160(userAddr));
                    sendMoneyToUser(sendAddr, resultMoney);
                }
            }

        }
        _time = now;
    }

    function isEnoughBalance(uint sendMoney) private view returns (bool, uint){
        if (sendMoney >= address(this).balance) return (false, address(this).balance);
        else return (true, sendMoney);
    }

    function sendFeetoAdmin(uint amount) private {
        devAddr.transfer(amount.div(20));
    }

    function sendMoneyToUser(address payable userAddress, uint money) private {
        if (money > 0) userAddress.transfer(money);
    }

    function isUsed(string memory code) public view returns (bool) {
        address addr = addressMapping[code];
        return uint(addr) != 0;
    }

    function getUserAddressByCode(string memory code) public view returns (address) {
        require(isWhitelistAdmin(msg.sender), "Permission denied");
        return addressMapping[code];
    }

    function registerUser(address addr, string memory inviteCode, string memory beCode) private {
        UserGlobal storage userGlobal = userMapping[addr];
        uid++;
        userGlobal.id = uid;
        userGlobal.userAddress = addr;
        userGlobal.inviteCode = inviteCode;
        userGlobal.beCode = beCode;
        addressMapping[inviteCode] = addr;
        indexMapping[uid] = addr;
    }

    function endRound() external onlyOwner {
        require(address(this).balance < 1 ether, "contract balance must be lower than 1 ether");
        rid++;
        startTime = now.add(period).div(1 days).mul(1 days);
        canSetStartTime = 1;
    }

    function donnottouch() public view returns (uint, uint, uint, uint, uint, uint, uint, uint, uint, uint, uint, uint) {
        return (
        rid,
        uid,
        startTime,
        rInvestCount[rid],
        rInvestMoney[rid],
        bonuslimit,
        sendLimit,
        withdrawLimit,
        canImport,
        lineStatus,
        lineArrayMapping[rid].length,
        canSetStartTime
        );
    }

    function getUserByAddress(address addr, uint roundId) public view returns (uint[15] memory info, string memory inviteCode, string memory beCode) {
        require(isWhitelistAdmin(msg.sender) || msg.sender == addr, "Permission denied for view user's privacy");
        if (roundId == 0) roundId = rid;
        UserGlobal memory userGlobal = userMapping[addr];
        User memory user = userRoundMapping[roundId][addr];
        info[0] = userGlobal.id;
        info[1] = user.lineAmount;
        info[2] = user.freeAmount;
        info[3] = user.freezeAmount;
        info[4] = user.inviteAmonut;
        info[5] = user.bonusAmount;
        info[6] = user.lineLevel;
        info[7] = user.dayBonusAmount;
        info[8] = user.rewardIndex;
        info[9] = user.investTimes;
        info[10] = user.level;
        uint grantAmount = 0;
        if (user.id > 0 && user.freezeAmount >= 1 ether && user.freezeAmount <= bonuslimit && user.investTimes < 7 && userGlobal.status != 1) grantAmount += user.dayBonusAmount;
        if (userGlobal.status == 0) {
            uint inviteSend = 0;
            AwardData memory awData = userAwardDataMapping[rid][user.userAddress][user.rewardIndex];
            uint lineAmount = user.freezeAmount.add(user.freeAmount).add(user.lineAmount);
            if (lineAmount >= 1 ether) {
                uint lineValue = lineAmount.div(ethWei);
                if (lineValue >= 15) inviteSend += awData.threeInvAmount;
                else {
                    if (user.lineLevel == 1 && lineAmount >= 1 ether && awData.oneInvAmount > 0) inviteSend += awData.oneInvAmount.div(15).mul(lineValue).div(2);
                    if (user.lineLevel == 2 && lineAmount >= 1 ether && (awData.oneInvAmount > 0 || awData.twoInvAmount > 0)) {
                        inviteSend += awData.oneInvAmount.div(15).mul(lineValue).mul(7).div(10);
                        inviteSend += awData.twoInvAmount.div(15).mul(lineValue).mul(5).div(7);
                    }
                    if (user.lineLevel == 3 && lineAmount >= 1 ether && awData.threeInvAmount > 0) inviteSend += awData.threeInvAmount.div(15).mul(lineValue);
                    if (user.lineLevel < 3) {
                        uint fireSc = getFireScByLevel(user.lineLevel);
                        inviteSend = inviteSend.mul(fireSc).div(10);
                    }
                }
                grantAmount += inviteSend;
            }
        }
        info[11] = grantAmount;
        info[12] = user.lastRwTime;
        info[13] = userGlobal.status;
        info[14] = user.bigCycle;
        return (info, userGlobal.inviteCode, userGlobal.beCode);
    }

    function getUserAddressById(uint id) public view returns (address) {
        require(isWhitelistAdmin(msg.sender), "Permission denied");
        return indexMapping[id];
    }

    function getLineUserId(uint index, uint rouId) public view returns (uint) {
        require(isWhitelistAdmin(msg.sender), "Permission denied");
        if (rouId == 0) rouId = rid;
        return lineArrayMapping[rid][index];
    }
}

library SafeMath {
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(c / a == b, "mul overflow");
        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "div zero");
        uint256 c = a / b;
        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "lower sub bigger");
        uint256 c = a - b;
        return c;
    }

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "overflow");
        return c;
    }

    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b != 0, "mod zero");
        return a % b;
    }

    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? b : a;
    }
}