Contract 0xe5d7df5a6a057b6a909d564dddabdc848e51a038 2

 
 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0x57a5f288ce2d6e329e1743a582e2d30eaffbcbb50751800d956053a0d320cd13Buy Entries301730012022-06-30 11:08:372 days 12 hrs ago0xa1db19aba15906df9355f7d1f32b1a8c6afe2a4f IN  0xe5d7df5a6a057b6a909d564dddabdc848e51a0380 MATIC0.015131670411 37.481813323
0x26835755a4b91b9a3c66e12752e832edb79d03149e300870b8be1b6010e1b44cBuy Entries301632092022-06-30 5:12:462 days 18 hrs ago0x4819da611933e182d798c88cdd283e54ac9b96b2 IN  0xe5d7df5a6a057b6a909d564dddabdc848e51a0380 MATIC0.02756595817 68.282091147
0xc3fb738293b1eb65a32ed136bc093b55d6c078e27e48f1de2c1ec28996ad7a10Withdraw Rewards301584792022-06-30 2:12:572 days 21 hrs ago0x4819da611933e182d798c88cdd283e54ac9b96b2 IN  0xe5d7df5a6a057b6a909d564dddabdc848e51a0380 MATIC0.002317026275 30.000081258
0x218512cde978eb580bccd5dc2a39102a7dfcfa533c4f72193bc20e8b826627a1Withdraw Rewards301381592022-06-29 13:37:403 days 9 hrs ago0x67acb72ea79131bb6061470413221b3584fce640 IN  0xe5d7df5a6a057b6a909d564dddabdc848e51a0380 MATIC0.001948662878 30.009900489
0xb16ac995b73f9018349fd69e4928eb11067996b34515caa07fcfe30ad034c5f8Withdraw Rewards301381152022-06-29 13:36:123 days 9 hrs ago0xdb16675035104b49c83def7411128829d231f372 IN  0xe5d7df5a6a057b6a909d564dddabdc848e51a0380 MATIC0.002463865926 30.034692033
0xf2e544dab9b89b40b64d24d472a4365e62b491251d4f41daff5b534ab0714571Withdraw Rewards301329312022-06-29 10:18:433 days 13 hrs ago0x52af078fad9c20dadb5b4a2d54c88b221d83da8f IN  0xe5d7df5a6a057b6a909d564dddabdc848e51a0380 MATIC0.003117292 38.000000009
0x6a2fa1a1f8cc4887644732cb2f35f2680536600bcbc90fb70797a4efd9695286Buy Entries301293832022-06-29 8:14:043 days 15 hrs ago0xe55effee896501a7f1e4cb583bae1ff2f8f2a85d IN  0xe5d7df5a6a057b6a909d564dddabdc848e51a0380 MATIC0.016655897118 30.000030834
0xea7bde0c508063e4d9c5c67c6adb6a95873e4d2322e6d74afa9e6220c4738f97Withdraw Rewards301258152022-06-29 6:00:213 days 17 hrs ago0x86e075e311d5ea298b69bd9204c933ee077eed39 IN  0xe5d7df5a6a057b6a909d564dddabdc848e51a0380 MATIC0.003183210364 38.803549311
0x8815617c7749457fa342f286c98a8340c797167be6a740695f7504696282e55fCalculate Round ...301239292022-06-29 4:47:173 days 18 hrs ago0x2f2e1f88cdc2ccbf12376708279c3b97eec33d46 IN  0xe5d7df5a6a057b6a909d564dddabdc848e51a0380 MATIC0.029285656978 60.340000039
0xb69d95f8e95fb1d0e9aed9e5e859afa8f6b20e88b20aa8e881209dfee2007d84Provide Missing ...301221812022-06-29 3:42:563 days 19 hrs ago0x2f2e1f88cdc2ccbf12376708279c3b97eec33d46 IN  0xe5d7df5a6a057b6a909d564dddabdc848e51a0380 MATIC0.001658130009 30.000000165
0x4be02e0ee66d11a1c4055d5587671c853b7a4e56e1ce15d22a46f826851e7353Provide Sealed S...301215662022-06-29 3:19:383 days 20 hrs ago0x2f2e1f88cdc2ccbf12376708279c3b97eec33d46 IN  0xe5d7df5a6a057b6a909d564dddabdc848e51a0380 MATIC0.0029357430
0xdc788c8dbbf010ef5267356a99b0f8d8ba8a110b958d88dbab92f7ce1a5b535cBuy Entries301150972022-06-28 23:19:594 days 8 mins ago0xdc2720a762c5bf9deeeb54460cc8fa8a2b62fac7 IN  0xe5d7df5a6a057b6a909d564dddabdc848e51a0380 MATIC0.012111570005 30.000000013
0xc888eb4d04fca159899ad73132fb0f05d3e102e3921bf9860fde80cee89d8595Buy Entries301145632022-06-28 23:01:394 days 27 mins ago0x008397a89dc8acd9053a1a2ef0f9b5f1c73da25c IN  0xe5d7df5a6a057b6a909d564dddabdc848e51a0380 MATIC0.011967570005 30.000000015
0x57afa5a2234caea17208ed140b7d307824903d51c02a82a11808d2922c4726e9Buy Entries301145082022-06-28 22:59:454 days 28 mins ago0x3813443d79ad67e792306344b0fd6b1eba977f01 IN  0xe5d7df5a6a057b6a909d564dddabdc848e51a0380 MATIC0.011967570005 30.000000013
0xd932f78700e98e80befd34d2e882ae821d6a1c334600d36f176e16c047a67419Buy Entries301144992022-06-28 22:59:274 days 29 mins ago0x5d191ee6a76195f02197fc36a253783d91f53bab IN  0xe5d7df5a6a057b6a909d564dddabdc848e51a0380 MATIC0.011967570005 30.000000013
0x72edd5a70df8faecc3a3d00cecd98ec80d27f325d75c8d4d91a48db8248b4e0dBuy Entries301144942022-06-28 22:59:134 days 29 mins ago0x6236513c547734eddaf89ac498d8043ebbdab68a IN  0xe5d7df5a6a057b6a909d564dddabdc848e51a0380 MATIC0.011967570005 30.000000014
0x00fc7bd815e528d9bdd31de1de2eb5a91715dfd1634d6717cababe14d14627e8Buy Entries301144872022-06-28 22:58:594 days 29 mins ago0xefb92bc6ed13f74c3140613684cffbcc3067a2c9 IN  0xe5d7df5a6a057b6a909d564dddabdc848e51a0380 MATIC0.011967570005 30.000000014
0x58d4c17d3358be2259108b71feb18d01bbf6dadc74afd5468eb5a10045edd4beBuy Entries301144842022-06-28 22:58:534 days 29 mins ago0x2ffe44153ed33da01d056c860921ea3cf52bf3fa IN  0xe5d7df5a6a057b6a909d564dddabdc848e51a0380 MATIC0.011967570004 30.000000012
0x5bdd8ec0638b5797cc69f0d2720a3dcfddf2391980e05a10a12b5a9c5357672aBuy Entries301144472022-06-28 22:57:394 days 31 mins ago0x38e194964c16aaa180fe91a7594d50521bda4f6c IN  0xe5d7df5a6a057b6a909d564dddabdc848e51a0380 MATIC0.011967570005 30.000000013
0x39ce6e03b47e20273ef40c7f31879983fe5c97968c5857d1728fc4fafb3b48f3Buy Entries301144352022-06-28 22:57:154 days 31 mins ago0x43d6d58e81508ec262e362268d88eab6d1e1fe6a IN  0xe5d7df5a6a057b6a909d564dddabdc848e51a0380 MATIC0.011967570005 30.000000013
0x465057aa827e6dbea79c14664239142625c9fe351da95fe85f7ac127a5fd8eedBuy Entries301144242022-06-28 22:56:494 days 31 mins ago0x3cceecab3b922e223bbbbfae537ffc8053abe509 IN  0xe5d7df5a6a057b6a909d564dddabdc848e51a0380 MATIC0.011967570004 30.000000012
0xce3a9b7771d96f99af0b677a2287f76371c7fc8e097265927d4de53cf9ba80bbBuy Entries301144242022-06-28 22:56:494 days 31 mins ago0xed171f05d4a6875a3eddb402f4e231680095d6d5 IN  0xe5d7df5a6a057b6a909d564dddabdc848e51a0380 MATIC0.011967570004 30.000000012
0x7358c23f10c4b9267fbfd8f0df7928c45c6fa7d6f6fb6f497124fbda09087329Buy Entries301144242022-06-28 22:56:494 days 31 mins ago0xdb16675035104b49c83def7411128829d231f372 IN  0xe5d7df5a6a057b6a909d564dddabdc848e51a0380 MATIC0.011967570004 30.000000012
0x36fced9dfdeb9077bf6863b5919224b809982111e871204cf5e4bc17fd749db0Buy Entries301143942022-06-28 22:55:494 days 32 mins ago0xc3d9e700bcb857619a829bd20802c89f76470d42 IN  0xe5d7df5a6a057b6a909d564dddabdc848e51a0380 MATIC0.011967570005 30.000000013
0xfab1a2606a8d00e9acd7cc35666f06f42765e35d73e17161a1bc36fa9b7cd8bfBuy Entries301143542022-06-28 22:54:254 days 34 mins ago0xbeae16b2128170d92119f7523af627dc2a4f80e4 IN  0xe5d7df5a6a057b6a909d564dddabdc848e51a0380 MATIC0.011967570004 30.000000012
[ Download CSV Export 
Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
LotteryLikePool

Compiler Version
v0.6.12+commit.27d51765

Optimization Enabled:
No with 200 runs

Other Settings:
constantinople EvmVersion, None license

Contract Source Code (Solidity Standard Json-Input format)

File 1 of 8 : LotteryLikePool.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;

import "openzeppelin-solidity/contracts/math/Math.sol";
import "openzeppelin-solidity/contracts/math/SafeMath.sol";
import "openzeppelin-solidity/contracts/token/ERC20/IERC20.sol";
import "openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol";

import "./LinkedList.sol";
import "./TwoStageOwnable.sol";

contract LotteryLikePool is TwoStageOwnable {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;
    using LinkedListLib for LinkedList;

    /// @notice Returns the time (in seconds) the owner has to verify the random seed
    function ownerSubmittingPeriod() public virtual pure returns (uint256) {
        return 1 days;
    }

    /// @notice Returns the time (in seconds) that the participants have to withdraw their rewards after round is closed
    function rewardWithdrawalPeriod() public virtual pure returns (uint256) {
        return 6 days;
    }

    /// @notice Returns duration of one round (in seconds)
    function roundPeriod() public virtual pure returns (uint256) {
        return 1 weeks;
    }

    /// @return Block number in which transaction applies
    /// @dev Method is virtual to override it for tests
    function getBlockNumber() internal virtual view returns (uint256) {
        return block.number;
    }

    /// @return Timestamp of block in which transaction applies
    /// @dev Method is virtual to override it for tests
    function getTimestamp() internal virtual view returns (uint256) {
        return block.timestamp;
    }

    /// @return Hash of specific block
    /// @dev Method is virtual to override it for tests
    function getBlockhash(uint256 blockNumber) internal virtual view returns (bytes32) {
        return blockhash(blockNumber);
    }

    struct ActiveEntryListElement {
        Entry entry;
        LinkedNode linkedNode;
    }

    /// @dev Represents entry (or entries) for a single round
    /// @param active True if entry is active and false otherwise.
    ///     All new entries are active. But entry can be deactivated during result calculation process
    /// @param amount Amount of entries. Equals to paid amount / 1e18
    /// @param from Sum of all previous active entries amounts
    /// @param pointer Pointer in active entries list
    /// @param to The same as `from` but with added amount
    /// @param account Address of entries owner
    struct Entry {
        bool active;
        uint256 amount;
        uint256 from;
        uint256 pointer;
        uint256 to;
        address account;
    }

    /// @dev Represents single participant of a single round
    /// @param active True if account is participant of round
    /// @param rewardPaid True if participant reward paid and false if they are not paid or participant has no rewards
    /// @param winner True if participant is winner
    /// @param entriesCount Sum of participant entries amounts
    /// @param reward Reward amount of participant
    struct RoundParticipant {
        bool active;
        bool rewardPaid;
        bool winner;
        uint256 entriesCount;
        uint256 reward;
    }

    /// @dev Represents common information of round
    /// @param closed True if round is closed and winners are defined
    /// @param closedAt Timestamp (in seconds) of round closing. Equals to `0` if round not closed
    /// @param endsAt Timestamp (in seconds) of round ending. When round ended buying entries for it not possible
    /// @param index Round index
    /// @param nonWithdrawnRewards Sum of rewards that has not been withdrawn.
    ///     Increases on every `increasePool` method call and reduced by method `withdrawRewards`.
    ///     When non withdrawn rewards are reused in other round `nonWithdrawnRewards` will be equals to 0
    ///     (reusing rewards are the same as withdrawing them and increasing pool of another round)
    /// @param totalEntries Sum of entries amounts
    /// @param totalReward Amount of rewards pool. Increases on every `increasePool` call. Never reduced
    /// @param participants Array of participants addresses
    /// @param winners Array of winners addresses
    struct RoundProps {
        bool closed;
        uint256 closedAt;
        uint256 endsAt;
        uint256 index;
        uint256 nonWithdrawnRewards;
        uint256 totalEntries;
        uint256 totalReward;
        address[] participants;
        address[] winners;
    }

    /// @dev Represents technical information about round results calculation process
    /// @param sealedSeedProvided True if sealed seed provided (see method `provideSealedSeed`)
    /// @param activeEntriesAmount Sum of active entries amounts. Reduces by gaps resolving
    /// @param gapPointer Pointer of entry that should be removed from active entries list
    /// @param iteratedEntriesCount Count of iterated entries
    /// @param passedIterationsCount Count of passed iterations
    /// @param seedRevealingBlockNumber Block number after which sealed seed can be revealed.
    ///     Hash of block with this number will be used to generate random seed.
    ///     Sealed seed can not be revealed after `seedRevealingBlockNumber` + 256
    /// @param sealedSeed Sealed seed - hash of original seed
    /// @param seed Seed of round that used to calculate results
    struct RoundCalculation {
        bool sealedSeedProvided;
        uint256 activeEntriesAmount;
        uint256 gapPointer;
        uint256 iteratedEntriesCount;
        uint256 passedIterationsCount;
        uint256 seedRevealingBlockNumber;
        bytes32 sealedSeed;
        bytes32 seed;
    }

    /// @dev Represents full round information
    /// @param props Common properties of round (see `RoundProps` struct for details)
    /// @param calculation Technical information about round results calculation process
    ///     (see `RoundCalculation` struct for details)
    /// @param activeEntries List of active entries. Used in calculation.
    ///     Not moved to `RoundCalculation` structure since linked list has mapping in it
    /// @param entries Array of all entries
    /// @param participants Map of participants. Key is participant address. Value is `RoundParticipant` structure
    struct Round {
        RoundProps props;
        RoundCalculation calculation;
        LinkedList activeEntries;
        Entry[] entries;
        mapping(address => RoundParticipant) participants;
    }

    /// @dev Total amount of tokens that have been spent buying entries but not withdrawn by owner
    uint256 private _totalStaked;

    /// @dev ERC20 staking token address. Used for buying entries
    IERC20 private _stakingToken;

    /// @dev ERC20 jackpot token address. Used for paying rewards
    IERC20 private _jackpotToken;

    /// @dev Rewards dividers for first 5 winners.
    ///     Reward can be calculated using `totalReward/rewardsDivider[winnerIndex]`
    uint256[5] private rewardsDivider = [2, 4, 8, 16, 16];

    /// @dev Array of all rounds. See `Round` structure for details
    Round[] private rounds;

    /// @notice Returns total amount of tokens that have been spent buying entries but not withdrawn by owner
    function totalStaked() public view returns (uint256) {
        return _totalStaked;
    }

    /// @notice Returns address of staking token (this is the one that used for buying entries)
    function stakingToken() public view returns (IERC20) {
        return _stakingToken;
    }

    /// @notice Returns address of jackpot token (this is the one that used for paying rewards)
    function jackpotToken() public view returns (IERC20) {
        return _jackpotToken;
    }

    /// @notice Returns count of already created rounds
    function roundsCount() public view returns (uint256) {
        return rounds.length;
    }

    /// @notice Returns all entries of specific round
    /// @param roundIndex Round index for which entries list should be returned
    function roundEntries(uint256 roundIndex) public view returns (Entry[] memory) {
        return _getRound(roundIndex).entries;
    }

    /// @notice Returns common round information. See struct `RoundProps` for details
    /// @param roundIndex Round index for which information should be returned
    function round(uint256 roundIndex) public view returns (RoundProps memory) {
        return _getRound(roundIndex).props;
    }

    /// @notice Returns information about round calculations. See struct `RoundCalculation` for details
    /// @param roundIndex Round index for which information should be returned
    function roundCalculation(uint256 roundIndex) public view returns (RoundCalculation memory) {
        return _getRound(roundIndex).calculation;
    }

    /// @notice Returns round participant inforation. See struct `RoundParticipant` for details
    /// @param roundIndex Round index for which inforation should be returned
    /// @param account Address of participant for which inforation should be returned
    function roundParticipant(uint256 roundIndex, address account) public view returns (RoundParticipant memory) {
        Round storage round_ = _getRound(roundIndex);
        return round_.participants[account];
    }

    /// @dev Returns list of currently active entries. May changes when calculation in process
    /// @return head Pointer of first active entry
    /// @return last Pointer of last active entry
    /// @return lastAllocation Pointer of last created entry
    /// @return length Count of active entries
    /// @return result Array of active entries and its list's element property
    function activeEntriesList(uint256 roundIndex)
        public
        view
        returns (
            uint256 head,
            uint256 last,
            uint256 lastAllocation,
            uint256 length,
            ActiveEntryListElement[] memory result
        )
    {
        Round storage round_ = _getRound(roundIndex);
        LinkedList storage list = round_.activeEntries;
        head = list.head;
        last = list.last;
        lastAllocation = list.it;
        length = list.length;
        result = new ActiveEntryListElement[](length);
        uint256 it = list.head;
        for (uint256 index = 0; index < length; index += 1) {
            LinkedNode memory node = list.getNode(it);
            result[index] = ActiveEntryListElement({entry: round_.entries[node.value], linkedNode: node});
            it = node.next;
        }
    }

    event EntriesPurchased(
        uint256 indexed roundIndex,
        address indexed purchaser,
        uint256 indexed entryIndex,
        uint256 amount
    );
    event JackpotIncreased(uint256 indexed roundIndex, address indexed payer, uint256 amount);
    event NonWithdrawnRewardsReused(uint256 indexed fromRoundIndex, uint256 indexed inRoundIndex);
    event MissingSeedProvided(uint256 indexed roundIndex, bytes32 seed);
    event NewRoundCreated(uint256 indexed index, uint256 endsAt);
    event SealedSeedProvided(uint256 indexed roundIndex, bytes32 sealedSeed, uint256 revealingBlockNumber);
    event SeedRevealed(uint256 indexed roundIndex, bytes32 revealedSeed, bytes32 savedSeed);
    event StakeWithdrawn(uint256 amount);
    event RewardWithdrawn(uint256 indexed roundIndex, address indexed winner, uint256 amount);
    event RoundClosed(uint256 indexed index);
    event RoundEnded(uint256 indexed index);
    event WinnerDefined(uint256 indexed roundIndex, address indexed account, uint256 rewardAmount);

    /// @param stakingToken_ ERC20 token that will be used to buy entries
    /// @param jackpotToken_ ERC20 token that will be used as rewards of rounds
    /// @param firstRoundEndsAt Timestamp (in seconds) when first created round will ends
    /// @param owner_ Address of owner
    constructor(
        IERC20 stakingToken_,
        IERC20 jackpotToken_,
        uint256 firstRoundEndsAt,
        address owner_
    ) public TwoStageOwnable(owner_) {
        _stakingToken = stakingToken_;
        _jackpotToken = jackpotToken_;
        rounds.push();
        rounds[0].props.endsAt = firstRoundEndsAt;
    }

    /// @notice Calculates specific round results
    /// @param roundIndex Index of round
    /// @param iterableEntries Array of entries indexes that expected to be iterated
    /// @param iterableEntriesOffset Count of skipped iterable entries. Needed to solve race conditions
    /// @param limit Max count of iterations that should be passed in transaction
    function calculateRoundResults(
        uint256 roundIndex,
        uint256[] memory iterableEntries,
        uint256 iterableEntriesOffset,
        uint256 limit
    ) external returns (bool success) {
        require(limit > 0, "Limit not positive");
        Round storage round_ = _getRound(roundIndex);
        require(round_.calculation.seed != bytes32(0), "Seed not revealed");
        require(!round_.props.closed, "Result already has been calculated");
        require(iterableEntriesOffset <= round_.calculation.iteratedEntriesCount, "Gap in iterable entries list");
        if (round_.calculation.gapPointer == 0) {
            // if there is first calculation call
            // or if there is no resolved gap in last iteration of previous calculation
            // then next iterable entries should be provided
            require(
                iterableEntries.length.add(iterableEntriesOffset) > round_.calculation.iteratedEntriesCount,
                "Nothing to calculate"
            );
        }
        _calculateResults(round_, iterableEntries, iterableEntriesOffset, limit);
        return true;
    }

    /// @notice Creates new round
    function createNewRound() public returns (bool success) {
        uint256 timestamp = getTimestamp();
        uint256 roundsCount_ = rounds.length;
        rounds.push();
        Round storage newRound = rounds[roundsCount_];
        Round storage previousRound = rounds[roundsCount_.sub(1)];
        uint256 newRoundEndsAt;
        uint256 roundPeriod_ = roundPeriod();
        if (previousRound.props.endsAt >= timestamp) newRoundEndsAt = previousRound.props.endsAt.add(roundPeriod_);
        else {
            uint256 passedWeeksCount = timestamp.sub(previousRound.props.endsAt).div(roundPeriod_);
            newRoundEndsAt = previousRound.props.endsAt.add(passedWeeksCount.add(1).mul(roundPeriod_));
        }
        newRound.props.endsAt = newRoundEndsAt;
        emit NewRoundCreated(roundsCount_, newRoundEndsAt);
        newRound.props.index = roundsCount_;
        return true;
    }

    /// @notice Method to buy entries. Should approve `amount` * 1e18 of staking token for using by this contract
    /// @param roundIndex Index of round to participate in. Round should not be ended
    /// @param amount Amount of entries to buy
    function buyEntries(uint256 roundIndex, uint256 amount) external onlyPositiveAmount(amount) returns (bool success) {
        _updateRound();
        address participant = msg.sender;
        Round storage round_ = _getRound(roundIndex);
        require(round_.props.endsAt > getTimestamp(), "Round already ended");
        uint256 newTotalAmount = round_.calculation.activeEntriesAmount.add(amount);
        Entry[] storage entries = round_.entries;
        uint256 newEntryIndex = entries.length;
        LinkedList storage roundActiveEntries = round_.activeEntries;
        uint256 pointer = roundActiveEntries.insert(roundActiveEntries.last, newEntryIndex);
        entries.push(
            Entry({
                active: true,
                amount: amount,
                from: round_.calculation.activeEntriesAmount,
                pointer: pointer,
                to: newTotalAmount,
                account: participant
            })
        );
        round_.calculation.activeEntriesAmount = newTotalAmount;
        round_.props.totalEntries = newTotalAmount;
        RoundParticipant storage roundParticipant_ = round_.participants[participant];
        roundParticipant_.entriesCount = roundParticipant_.entriesCount.add(amount);
        if (!roundParticipant_.active) {
            roundParticipant_.active = true;
            round_.props.participants.push(participant);
        }
        uint256 stakeAmount = amount.mul(10**18);
        _totalStaked = _totalStaked.add(stakeAmount);
        emit EntriesPurchased(roundIndex, participant, newEntryIndex, amount);
        _stakingToken.safeTransferFrom(participant, address(this), stakeAmount);
        return true;
    }

    /// @notice Increases round jackpot. Should approve `amount` of jackpot token for using by this contract
    /// @param roundIndex Index of round in which jackpot should be increased. Round should not be ended
    /// @param amount Amount of increasing
    function increaseJackpot(uint256 roundIndex, uint256 amount)
        public
        onlyPositiveAmount(amount)
        returns (bool success)
    {
        _updateRound();
        Round storage round_ = _getRound(roundIndex);
        require(round_.props.endsAt > getTimestamp(), "Round already ended");
        round_.props.totalReward = round_.props.totalReward.add(amount);
        round_.props.nonWithdrawnRewards = round_.props.nonWithdrawnRewards.add(amount);
        emit JackpotIncreased(roundIndex, msg.sender, amount);
        _jackpotToken.safeTransferFrom(msg.sender, address(this), amount);
        return true;
    }

    /// @notice Provides missing seed. Method added to fill case, when owner not provides seed by himself.
    ///     Conditions of successful providing:
    ///      * Seed should not been provided before it;
    ///      * If sealed seed provided by owner then more than 256 blocks should be produced after that;
    ///      * If sealed seed not provided owner submitting period should be ended.
    ///     Sets round seed to hash of previous block. Not the most honest implementation.
    ///     But since this is only a fuse in case the owner does not do his job, that's okay.
    /// @param roundIndex Round index for which missing seed provided
    function provideMissingSeed(uint256 roundIndex) public returns (bool success) {
        Round storage round_ = _getRound(roundIndex);
        uint256 blockNumber = getBlockNumber();
        require(round_.calculation.seed == bytes32(0), "Seed already provided");
        uint256 endsAt = round_.props.endsAt;
        if (round_.calculation.sealedSeedProvided) {
            bool revealingPhase = blockNumber > round_.calculation.seedRevealingBlockNumber;
            bool blockHashable = getBlockhash(round_.calculation.seedRevealingBlockNumber) != bytes32(0);
            require(revealingPhase && !blockHashable, "Less than 256 blocks passed from providing sealed seed");
        } else require(endsAt.add(ownerSubmittingPeriod()) < getTimestamp(), "Owner submitting period not passed");
        round_.calculation.sealedSeedProvided = true;
        bytes32 seed = getBlockhash(blockNumber.sub(1));
        round_.calculation.seed = seed;
        emit MissingSeedProvided(roundIndex, seed);
        return true;
    }

    /// @notice Provides sealed seed for random. Applicable only by contract owner
    /// @param roundIndex Round index for which sealed seed provided
    /// @param sealedSeed Keccak-256 hash of original seed. Original seed should be a random 32 bytes.
    ///     Original seed also should be remembered to provide it in `revealSealedSeed` method
    function provideSealedSeed(uint256 roundIndex, bytes32 sealedSeed) public onlyOwner returns (bool success) {
        Round storage round_ = _getRound(roundIndex);
        require(!round_.calculation.sealedSeedProvided, "Sealed seed already provided");
        require(round_.props.endsAt <= getTimestamp(), "Round not ended");
        round_.calculation.sealedSeedProvided = true;
        round_.calculation.sealedSeed = sealedSeed;
        uint256 revealingBlockNumber = getBlockNumber() + 1;
        round_.calculation.seedRevealingBlockNumber = revealingBlockNumber;
        emit SealedSeedProvided(roundIndex, sealedSeed, revealingBlockNumber);
        return true;
    }

    /// @notice Will reuse non withdrawn rewards as jackpot of the current one.
    ///     "From" round should be closed and reward withdrawal period should be passed.
    ///     Also appicable when round ended but there is no participants in it
    /// @param fromRoundIndex Round from which unwithdrawn rewards should be removed
    /// @param inRoundIndex Current round index
    function reuseNonWithdrawnRewards(uint256 fromRoundIndex, uint256 inRoundIndex) public returns (bool success) {
        _updateRound();
        uint256 timestamp = getTimestamp();
        RoundProps storage fromRoundProps = _getRound(fromRoundIndex).props;
        if (fromRoundProps.participants.length > 0) {
            require(fromRoundProps.closed, "From round not closed");
            uint256 applicableAt = fromRoundProps.closedAt.add(rewardWithdrawalPeriod());
            require(timestamp >= applicableAt, "Users can withdraw their rewards");
        } else require(timestamp >= fromRoundProps.endsAt, "Round not ended");
        uint256 reusedAmount = fromRoundProps.nonWithdrawnRewards;
        require(reusedAmount > 0, "Nothing to reuse");
        RoundProps storage inRoundProps = _getRound(inRoundIndex).props;
        require(timestamp < inRoundProps.endsAt, "In round already ended");
        require(timestamp >= _getRound(inRoundIndex.sub(1)).props.endsAt, "Able to reuse only for current round");
        fromRoundProps.nonWithdrawnRewards = 0;
        inRoundProps.totalReward = inRoundProps.totalReward.add(reusedAmount);
        inRoundProps.nonWithdrawnRewards = inRoundProps.nonWithdrawnRewards.add(reusedAmount);
        emit NonWithdrawnRewardsReused(fromRoundIndex, inRoundIndex);
        return true;
    }

    /// @notice Method to reveal sealed seed. Applicable only by contract owner.
    ///     Before revealing sealed seed it should be provided via `provideSealedSeed` method.
    ///     Applicable only next to 2 blocks after sealed seed has been provided but before next 256 blocks
    /// @param roundIndex Round index for which sealed seed should be revealed
    /// @param seed Original seed. See NatSpec for `provideSealedSeed` method
    function revealSealedSeed(uint256 roundIndex, bytes32 seed) public onlyOwner returns (bool success) {
        Round storage round_ = _getRound(roundIndex);
        require(round_.calculation.seed == bytes32(0), "Seed already revealed");
        require(round_.calculation.sealedSeedProvided, "Sealed seed not provided");
        uint256 seedRevealingBlockNumber = round_.calculation.seedRevealingBlockNumber;
        require(getBlockNumber() > seedRevealingBlockNumber, "Unable to reveal sealed seed on the same block");
        bytes32 revealingBlockHash = getBlockhash(seedRevealingBlockNumber);
        require(revealingBlockHash != bytes32(0), "More than 256 blocks passed from providing sealed seed");
        require(keccak256(abi.encodePacked(msg.sender, seed)) == round_.calculation.sealedSeed, "Invalid seed");
        bytes32 newSeed = keccak256(abi.encodePacked(revealingBlockHash, seed));
        round_.calculation.seed = newSeed;
        emit SeedRevealed(roundIndex, seed, newSeed);
        return true;
    }

    /// @notice Withdraws tokens, that have been spent buying entries. Applicable only by contract owner
    /// @param amount Amount of tokens to withdraw
    function withdrawStake(uint256 amount) external onlyOwner onlyPositiveAmount(amount) returns (bool success) {
        _totalStaked = _totalStaked.sub(amount, "Staking pool is extinguished");
        emit StakeWithdrawn(amount);
        _stakingToken.safeTransfer(owner, amount);
        return true;
    }

    /// @notice Withdraws rewards of specific round
    /// @param roundIndex Round index from which rewards should be withdrawn
    function withdrawRewards(uint256 roundIndex) external returns (bool success) {
        address caller = msg.sender;
        Round storage round_ = _getRound(roundIndex);
        RoundParticipant storage participant = round_.participants[caller];
        require(participant.winner, "Not a round winner");
        require(!participant.rewardPaid, "Round reward already paid");
        uint256 amount = participant.reward;
        require(amount > 0, "Reward amount is equal to zero");
        require(round_.props.nonWithdrawnRewards >= amount, "Reward reused as next jackpot");
        participant.rewardPaid = true;
        round_.props.nonWithdrawnRewards = round_.props.nonWithdrawnRewards.sub(amount);
        emit RewardWithdrawn(roundIndex, caller, amount);
        _jackpotToken.safeTransfer(caller, amount);
        return true;
    }

    /// @dev Creates new round if the last one is ended. Also emits `RoundEnded` event in this case
    function _updateRound() internal {
        uint256 lastRoundIndex = rounds.length.sub(1);
        if (rounds[lastRoundIndex].props.endsAt > getTimestamp()) return;
        emit RoundEnded(lastRoundIndex);
        createNewRound();
    }

    /// @dev Returns round by its index. Result is storage type so it can be modified to modify state.
    ///     Reverts an error when index greater than or equals to round count
    function _getRound(uint256 index) private view returns (Round storage) {
        require(index < rounds.length, "Round not found");
        return rounds[index];
    }

    /// @dev Calculates results of round
    /// @param round_ Storage type of round to calculate
    /// @param iterableEntries Array of entries indexes that expected to be iterated
    /// @param iterableEntriesOffset Number of entries that was skipped in `iterableEntries` array.
    ///     Needed to solve race conditions
    /// @param limit Max count of iteration to calculate
    function _calculateResults(
        Round storage round_,
        uint256[] memory iterableEntries,
        uint256 iterableEntriesOffset,
        uint256 limit
    ) private {
        uint256 passedIterationsCount = round_.calculation.passedIterationsCount;
        round_.calculation.passedIterationsCount = passedIterationsCount.add(1);
        // If previous iteration found entry to be removed
        //      or if it not resolves removing previously found removable entry
        if (round_.calculation.gapPointer > 0) {
            // process entry removing
            _processGap(round_);
            // and start new iteration if limit not reached
            if (limit > 1) _calculateResults(round_, iterableEntries, iterableEntriesOffset, limit - 1);
            return;
        }
        // Generate iteration seed by hashing round seed and iteration index
        uint256 random = uint256(keccak256(abi.encodePacked(round_.calculation.seed, passedIterationsCount)));
        uint256 iteratedEntriesCount = round_.calculation.iteratedEntriesCount;
        // If there is not enough indexes in `iterableEntries` list just finish calculation
        if (iterableEntries.length.add(iterableEntriesOffset) <= iteratedEntriesCount) return;
        // Get random number from 0 inclusive to total round entries exclusive
        random = random.mod(round_.calculation.activeEntriesAmount);
        // Get expected iterable entry
        uint256 potensionalIterableEntryIndex = iterableEntries[iteratedEntriesCount.sub(iterableEntriesOffset)];
        require(potensionalIterableEntryIndex < round_.entries.length, "Invalid iterable entry index");
        Entry storage potensionalIterableEntry = round_.entries[potensionalIterableEntryIndex];
        round_.calculation.iteratedEntriesCount = iteratedEntriesCount.add(1);
        // Expected iterable entry should be active (not removed from active list)
        require(potensionalIterableEntry.active, "Expected iterable entry not active");
        // Check that iterated entry is correct
        require(
            potensionalIterableEntry.from <= random && potensionalIterableEntry.to > random,
            "Invalid expected iterable entry"
        );
        address potensionalWinningAddress = potensionalIterableEntry.account;
        RoundParticipant storage roundParticipant_ = round_.participants[potensionalWinningAddress];
        // If entry owner not a winner
        if (!roundParticipant_.winner) {
            // make it winner
            bool shouldBreak = _processWinner(round_, roundParticipant_, potensionalWinningAddress);
            // and if he is the last winner (5th or no more non winners) just stop calculation
            if (shouldBreak) return;
        } else {
            // otherwise, if he is already winner mark his entry to remove
            round_.calculation.gapPointer = potensionalIterableEntry.pointer;
        }
        // If limit not reached start new iteration
        if (limit > 1) _calculateResults(round_, iterableEntries, iterableEntriesOffset, limit - 1);
    }

    /// @dev Process winner
    /// @param round_ Round in which winner is defined
    /// @param roundParticipant_ Round participant defined as a winner properties
    /// @param potensionalWinningAddress Address of participant
    /// @return shouldBreak True if this is the last round winner
    function _processWinner(
        Round storage round_,
        RoundParticipant storage roundParticipant_,
        address potensionalWinningAddress
    ) private returns (bool shouldBreak) {
        uint256 reward = round_.props.totalReward.div(rewardsDivider[round_.props.winners.length]);
        roundParticipant_.reward = reward;
        roundParticipant_.winner = true;
        round_.props.winners.push(potensionalWinningAddress);
        uint256 newCalculatedWinnersCount = round_.props.winners.length;
        emit WinnerDefined(round_.props.index, potensionalWinningAddress, reward);
        // If this is the last round winner (5th winner or no more non winners)
        if (newCalculatedWinnersCount >= 5 || newCalculatedWinnersCount >= round_.props.participants.length) {
            // close round
            emit RoundClosed(round_.props.index);
            round_.props.closed = true;
            round_.props.closedAt = getTimestamp();
            // and stop results calculations
            return true;
        }
        // else continue results calculation
        return false;
    }

    /// @dev Method to iterate entry removing
    /// @param round_ Round in which some entry should be removed
    function _processGap(Round storage round_) private {
        LinkedList storage list = round_.activeEntries;
        uint256 lastEntryIndex = list.get(list.last);
        Entry storage lastEntry = round_.entries[lastEntryIndex];
        LinkedNode memory gapNode = list.getNode(round_.calculation.gapPointer);
        Entry storage gap = round_.entries[gapNode.value];
        // If entry to remove is the last in active entries list
        if (list.last == round_.calculation.gapPointer) {
            // then just remove it
            round_.calculation.activeEntriesAmount = round_.calculation.activeEntriesAmount.sub(lastEntry.amount);
            list.remove(round_.calculation.gapPointer);
            round_.calculation.gapPointer = 0;
            gap.active = false;
            return;
        }
        RoundParticipant storage lastParticipant = round_.participants[lastEntry.account];
        // If owner of last entry in active entries list is a winner
        if (lastParticipant.winner) {
            // Just remove the last entry and continue processing removing
            round_.calculation.activeEntriesAmount = round_.calculation.activeEntriesAmount.sub(lastEntry.amount);
            list.remove(list.last);
            lastEntry.active = false;
            return;
        }
        // Otherwise we need to move last entry instead of removable entry
        // To do this moved entry amount should be calculated first
        //      that is minimal amount between removable entry amount and last entry remove
        uint256 transferAmount = Math.min(gap.amount, lastEntry.amount);
        round_.calculation.activeEntriesAmount = round_.calculation.activeEntriesAmount.sub(transferAmount);
        if (gapNode.prev > 0) {
            Entry storage prevEntry = round_.entries[list.get(gapNode.prev)];
            if (prevEntry.account == lastEntry.account) {
                // If owner of entry before removable one is the same as owner of last entry
                //      then just move amount from last entry to entry before removable one
                return _processTransitionToPrevGap(round_, prevEntry, gap, lastEntry, transferAmount, list);
            }
        }
        if (gapNode.next > 0 && gapNode.next != list.last) {
            Entry storage nextEntry = round_.entries[list.get(gapNode.next)];
            if (nextEntry.account == lastEntry.account) {
                // If owner of entry after removable one is the same as owner of last entry
                //      then just move amount from last entry to entry after removable one
                return _processTransitionToNextGap(round_, nextEntry, gap, lastEntry, transferAmount, list);
            }
        }
        // If neighboring entries has different owner
        //      just create new entry with this owner before the removable one and reduce removable entry amount
        uint256 newEntryIndex = round_.entries.length;
        uint256 newEntryFrom = gap.from;
        gap.from = gap.from.add(transferAmount);
        gap.amount = gap.amount.sub(transferAmount);
        lastEntry.amount = lastEntry.amount.sub(transferAmount);
        lastEntry.to = lastEntry.to.sub(transferAmount);
        uint256 pointer = list.insert(gapNode.prev, newEntryIndex);
        round_.entries.push(Entry(true, transferAmount, newEntryFrom, pointer, gap.from, lastEntry.account));
        // and remove last and removable entry if its amount is zero
        _finishGapTransfer(round_, gap, lastEntry, list);
    }

    /// @dev Moves entries amount from last entry to the first before removable one
    /// @param round_ Round in which this transition applies
    /// @param prevEntry First entry before removable one
    /// @param gap Removable entry
    /// @param lastEntry Last active entry
    /// @param transferAmount Amount that should be moved
    /// @param list List of active entries
    function _processTransitionToPrevGap(
        Round storage round_,
        Entry storage prevEntry,
        Entry storage gap,
        Entry storage lastEntry,
        uint256 transferAmount,
        LinkedList storage list
    ) private {
        prevEntry.amount = prevEntry.amount.add(transferAmount);
        prevEntry.to = prevEntry.to.add(transferAmount);
        gap.from = prevEntry.to;
        gap.amount = gap.amount.sub(transferAmount);
        lastEntry.to = lastEntry.to.sub(transferAmount);
        lastEntry.amount = lastEntry.amount.sub(transferAmount);
        _finishGapTransfer(round_, gap, lastEntry, list);
    }

    /// @dev Moves entries amount from last entry to the first after removable one
    /// @param round_ Round in which this transition applies
    /// @param nextEntry First entry after removable one
    /// @param gap Removable entry
    /// @param lastEntry Last active entry
    /// @param transferAmount Amount that should be moved
    /// @param list List of active entries
    function _processTransitionToNextGap(
        Round storage round_,
        Entry storage nextEntry,
        Entry storage gap,
        Entry storage lastEntry,
        uint256 transferAmount,
        LinkedList storage list
    ) private {
        nextEntry.amount = nextEntry.amount.add(transferAmount);
        nextEntry.from = nextEntry.from.sub(transferAmount);
        gap.to = nextEntry.from;
        gap.amount = gap.amount.sub(transferAmount);
        lastEntry.to = lastEntry.to.sub(transferAmount);
        lastEntry.amount = lastEntry.amount.sub(transferAmount);
        _finishGapTransfer(round_, gap, lastEntry, list);
    }

    /// @dev Finish iteration of removing entry
    /// @param round_ Round for which iteration was applied
    /// @param gap Removable entry
    /// @param lastEntry Last active entry
    /// @param list List of active entries
    function _finishGapTransfer(
        Round storage round_,
        Entry storage gap,
        Entry storage lastEntry,
        LinkedList storage list
    ) private {
        // If removable entry amount is zero (when its amount fully compensated by creation/transition amounts)
        if (gap.amount == 0) {
            // just remove removable entry
            gap.active = false;
            list.remove(round_.calculation.gapPointer);
            // and stop calculation removing
            round_.calculation.gapPointer = 0;
        }
        // If last entry is empty (fully moved instead of removable one)
        if (lastEntry.amount == 0) {
            // remove it
            lastEntry.active = false;
            list.remove(list.last);
        }
    }

    /// @dev Allows only positive amount (`> 0`)
    /// @param amount Amount to check
    modifier onlyPositiveAmount(uint256 amount) {
        require(amount > 0, "Amount is not positive");
        _;
    }
}

File 2 of 8 : TwoStageOwnable.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;

abstract contract TwoStageOwnable {
    address public nominatedOwner;
    address public owner;

    event OwnerChanged(address indexed newOwner);
    event OwnerNominated(address indexed nominatedOwner);

    constructor(address owner_) internal {
        require(owner_ != address(0), "Owner cannot be zero address");
        _setOwner(owner_);
    }

    function acceptOwnership() external returns (bool success) {
        require(msg.sender == nominatedOwner, "Not nominated to ownership");
        _setOwner(nominatedOwner);
        nominatedOwner = address(0);
        return true;
    }

    function nominateNewOwner(address owner_) external onlyOwner returns (bool success) {
        _nominateNewOwner(owner_);
        return true;
    }

    modifier onlyOwner {
        require(msg.sender == owner, "Ownable: caller is not the owner");
        _;
    }

    function _nominateNewOwner(address owner_) internal {
        nominatedOwner = owner_;
        emit OwnerNominated(owner_);
    }

    function _setOwner(address newOwner) internal {
        owner = newOwner;
        emit OwnerChanged(newOwner);
    }
}

File 3 of 8 : LinkedList.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;

struct LinkedNode {
    bool inited;
    uint256 value;
    uint256 prev;
    uint256 next;
}

struct LinkedList {
    uint256 head;
    uint256 last;
    mapping(uint256 => LinkedNode) mem;
    uint256 it;
    uint256 length;
}

library LinkedListLib {
    function insert(
        LinkedList storage self,
        uint256 bearingPointer,
        uint256 value
    ) internal returns (uint256 pointer) {
        LinkedNode storage node = self.mem[bearingPointer];
        require(node.inited || bearingPointer == 0, "LinkedList insert: pointer out of scope");
        self.it += 1;
        LinkedNode storage newNode = self.mem[self.it];
        newNode.inited = true;
        newNode.value = value;
        newNode.prev = bearingPointer;
        newNode.next = bearingPointer == 0 ? self.head : node.next;
        node.next = self.it;
        self.mem[newNode.prev].next = self.it;
        self.mem[newNode.next].prev = self.it;
        if (bearingPointer == 0) self.head = self.it;
        if (bearingPointer == self.last) self.last = self.it;
        self.length += 1;
        return self.it;
    }

    function remove(LinkedList storage self, uint256 pointer) internal {
        LinkedNode storage node = self.mem[pointer];
        require(node.inited, "LinkedList remove: pointer out of scope");
        node.inited = false;
        self.mem[node.prev].next = node.next;
        self.mem[node.next].prev = node.prev;
        if (self.head == pointer) self.head = node.next;
        if (self.last == pointer) self.last = node.prev;
        self.length -= 1;
    }

    function get(LinkedList storage self, uint256 pointer) internal view returns (uint256 value) {
        LinkedNode storage node = self.mem[pointer];
        require(node.inited, "LinkedList get: pointer out of scope");
        return node.value;
    }

    function getNode(LinkedList storage self, uint256 pointer) internal view returns (LinkedNode memory) {
        LinkedNode storage node = self.mem[pointer];
        require(node.inited, "LinkedList getNode: pointer out of scope");
        return node;
    }
}

File 4 of 8 : Address.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.6.2 <0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

File 5 of 8 : SafeERC20.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

import "./IERC20.sol";
import "../../math/SafeMath.sol";
import "../../utils/Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

File 6 of 8 : IERC20.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

File 7 of 8 : SafeMath.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

File 8 of 8 : Math.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow, so we distribute
        return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
    }
}

Settings
{
  "remappings": [],
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "evmVersion": "constantinople",
  "libraries": {},
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"contract IERC20","name":"stakingToken_","type":"address"},{"internalType":"contract IERC20","name":"jackpotToken_","type":"address"},{"internalType":"uint256","name":"firstRoundEndsAt","type":"uint256"},{"internalType":"address","name":"owner_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"roundIndex","type":"uint256"},{"indexed":true,"internalType":"address","name":"purchaser","type":"address"},{"indexed":true,"internalType":"uint256","name":"entryIndex","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EntriesPurchased","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"roundIndex","type":"uint256"},{"indexed":true,"internalType":"address","name":"payer","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"JackpotIncreased","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"roundIndex","type":"uint256"},{"indexed":false,"internalType":"bytes32","name":"seed","type":"bytes32"}],"name":"MissingSeedProvided","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"index","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"endsAt","type":"uint256"}],"name":"NewRoundCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"fromRoundIndex","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"inRoundIndex","type":"uint256"}],"name":"NonWithdrawnRewardsReused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnerChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"nominatedOwner","type":"address"}],"name":"OwnerNominated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"roundIndex","type":"uint256"},{"indexed":true,"internalType":"address","name":"winner","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RewardWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"index","type":"uint256"}],"name":"RoundClosed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"index","type":"uint256"}],"name":"RoundEnded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"roundIndex","type":"uint256"},{"indexed":false,"internalType":"bytes32","name":"sealedSeed","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"revealingBlockNumber","type":"uint256"}],"name":"SealedSeedProvided","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"roundIndex","type":"uint256"},{"indexed":false,"internalType":"bytes32","name":"revealedSeed","type":"bytes32"},{"indexed":false,"internalType":"bytes32","name":"savedSeed","type":"bytes32"}],"name":"SeedRevealed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"StakeWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"roundIndex","type":"uint256"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"rewardAmount","type":"uint256"}],"name":"WinnerDefined","type":"event"},{"inputs":[],"name":"acceptOwnership","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"roundIndex","type":"uint256"}],"name":"activeEntriesList","outputs":[{"internalType":"uint256","name":"head","type":"uint256"},{"internalType":"uint256","name":"last","type":"uint256"},{"internalType":"uint256","name":"lastAllocation","type":"uint256"},{"internalType":"uint256","name":"length","type":"uint256"},{"components":[{"components":[{"internalType":"bool","name":"active","type":"bool"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"from","type":"uint256"},{"internalType":"uint256","name":"pointer","type":"uint256"},{"internalType":"uint256","name":"to","type":"uint256"},{"internalType":"address","name":"account","type":"address"}],"internalType":"struct LotteryLikePool.Entry","name":"entry","type":"tuple"},{"components":[{"internalType":"bool","name":"inited","type":"bool"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"prev","type":"uint256"},{"internalType":"uint256","name":"next","type":"uint256"}],"internalType":"struct LinkedNode","name":"linkedNode","type":"tuple"}],"internalType":"struct LotteryLikePool.ActiveEntryListElement[]","name":"result","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"roundIndex","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"buyEntries","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"roundIndex","type":"uint256"},{"internalType":"uint256[]","name":"iterableEntries","type":"uint256[]"},{"internalType":"uint256","name":"iterableEntriesOffset","type":"uint256"},{"internalType":"uint256","name":"limit","type":"uint256"}],"name":"calculateRoundResults","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"createNewRound","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"roundIndex","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"increaseJackpot","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"jackpotToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner_","type":"address"}],"name":"nominateNewOwner","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"nominatedOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ownerSubmittingPeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"roundIndex","type":"uint256"}],"name":"provideMissingSeed","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"roundIndex","type":"uint256"},{"internalType":"bytes32","name":"sealedSeed","type":"bytes32"}],"name":"provideSealedSeed","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"fromRoundIndex","type":"uint256"},{"internalType":"uint256","name":"inRoundIndex","type":"uint256"}],"name":"reuseNonWithdrawnRewards","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"roundIndex","type":"uint256"},{"internalType":"bytes32","name":"seed","type":"bytes32"}],"name":"revealSealedSeed","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardWithdrawalPeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"roundIndex","type":"uint256"}],"name":"round","outputs":[{"components":[{"internalType":"bool","name":"closed","type":"bool"},{"internalType":"uint256","name":"closedAt","type":"uint256"},{"internalType":"uint256","name":"endsAt","type":"uint256"},{"internalType":"uint256","name":"index","type":"uint256"},{"internalType":"uint256","name":"nonWithdrawnRewards","type":"uint256"},{"internalType":"uint256","name":"totalEntries","type":"uint256"},{"internalType":"uint256","name":"totalReward","type":"uint256"},{"internalType":"address[]","name":"participants","type":"address[]"},{"internalType":"address[]","name":"winners","type":"address[]"}],"internalType":"struct LotteryLikePool.RoundProps","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"roundIndex","type":"uint256"}],"name":"roundCalculation","outputs":[{"components":[{"internalType":"bool","name":"sealedSeedProvided","type":"bool"},{"internalType":"uint256","name":"activeEntriesAmount","type":"uint256"},{"internalType":"uint256","name":"gapPointer","type":"uint256"},{"internalType":"uint256","name":"iteratedEntriesCount","type":"uint256"},{"internalType":"uint256","name":"passedIterationsCount","type":"uint256"},{"internalType":"uint256","name":"seedRevealingBlockNumber","type":"uint256"},{"internalType":"bytes32","name":"sealedSeed","type":"bytes32"},{"internalType":"bytes32","name":"seed","type":"bytes32"}],"internalType":"struct LotteryLikePool.RoundCalculation","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"roundIndex","type":"uint256"}],"name":"roundEntries","outputs":[{"components":[{"internalType":"bool","name":"active","type":"bool"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"from","type":"uint256"},{"internalType":"uint256","name":"pointer","type":"uint256"},{"internalType":"uint256","name":"to","type":"uint256"},{"internalType":"address","name":"account","type":"address"}],"internalType":"struct LotteryLikePool.Entry[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"roundIndex","type":"uint256"},{"internalType":"address","name":"account","type":"address"}],"name":"roundParticipant","outputs":[{"components":[{"internalType":"bool","name":"active","type":"bool"},{"internalType":"bool","name":"rewardPaid","type":"bool"},{"internalType":"bool","name":"winner","type":"bool"},{"internalType":"uint256","name":"entriesCount","type":"uint256"},{"internalType":"uint256","name":"reward","type":"uint256"}],"internalType":"struct LotteryLikePool.RoundParticipant","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"roundPeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"roundsCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakingToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalStaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"roundIndex","type":"uint256"}],"name":"withdrawRewards","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawStake","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000c3ec80343d2bae2f8e680fdadde7c17e71e114ea000000000000000000000000c2132d05d31c914a87c6611c10748aeb04b58e8f000000000000000000000000000000000000000000000000000000006153ac800000000000000000000000002f2e1f88cdc2ccbf12376708279c3b97eec33d46

-----Decoded View---------------
Arg [0] : stakingToken_ (address): 0xc3ec80343d2bae2f8e680fdadde7c17e71e114ea
Arg [1] : jackpotToken_ (address): 0xc2132d05d31c914a87c6611c10748aeb04b58e8f
Arg [2] : firstRoundEndsAt (uint256): 1632873600
Arg [3] : owner_ (address): 0x2f2e1f88cdc2ccbf12376708279c3b97eec33d46

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 000000000000000000000000c3ec80343d2bae2f8e680fdadde7c17e71e114ea
Arg [1] : 000000000000000000000000c2132d05d31c914a87c6611c10748aeb04b58e8f
Arg [2] : 000000000000000000000000000000000000000000000000000000006153ac80
Arg [3] : 0000000000000000000000002f2e1f88cdc2ccbf12376708279c3b97eec33d46


Deployed ByteCode Sourcemap

402:36769:1:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16733:630;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8992:215;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1038:92;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8577:149;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;659:147:2;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7959:132:1;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;23431:305;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8262:126;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;871:102;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;22245:1024;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;14778:1692;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;98:29:2;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7385:90:1;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;417:236:2;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;643:101:1;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19399:675;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7194:89;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;13630:895;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;133:20:2;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7577:90:1;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;23871:842;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7729:90;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;18024:1019;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9596:856;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;:::i;:::-;;;;;;;;20461:1337;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;12463:1127;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;16733:630;16861:12;16836:6;37123:1;37114:6;:10;37106:45;;;;;;;;;;;;:::i;:::-;;;;;;;;;16889:14:::1;:12;:14::i;:::-;16913:20;16936:21;16946:10;16936:9;:21::i;:::-;16913:44;;16997:14;:12;:14::i;:::-;16975:6;:12;;:19;;;:36;16967:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;17072:36;17101:6;17072;:12;;:24;;;:28;;:36;;;;:::i;:::-;17045:6;:12;;:24;;:63;;;;17153:44;17190:6;17153;:12;;:32;;;:36;;:44;;;;:::i;:::-;17118:6;:12;;:32;;:79;;;;17241:10;17212:48;;17229:10;17212:48;17253:6;17212:48;;;;;;:::i;:::-;;;;;;;;17270:65;17301:10;17321:4;17328:6;17270:13;;;;;;;;;;;:30;;;;:65;;;;;;:::i;:::-;17352:4;17345:11;;;16733:630:::0;;;;;:::o;8992:215::-;9076:23;;:::i;:::-;9111:20;9134:21;9144:10;9134:9;:21::i;:::-;9111:44;;9172:6;:19;;:28;9192:7;9172:28;;;;;;;;;;;;;;;9165:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8992:215;;;;:::o;1038:92::-;1090:7;1116;1109:14;;1038:92;:::o;8577:149::-;8644:23;;:::i;:::-;8686:21;8696:10;8686:9;:21::i;:::-;:33;;8679:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8577:149;;;:::o;659:147:2:-;729:12;863:5;;;;;;;;;;;849:19;;:10;:19;;;841:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;753:25:::1;771:6;753:17;:25::i;:::-;795:4;788:11;;659:147:::0;;;:::o;7959:132:1:-;8022:14;8055:21;8065:10;8055:9;:21::i;:::-;:29;;8048:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7959:132;;;:::o;23431:305::-;23525:12;863:5:2;;;;;;;;;;;849:19;;:10;:19;;;841:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;23508:6:1::1;37123:1;37114:6;:10;37106:45;;;;;;;;;;;;:::i;:::-;;;;;;;;;23564:56:::2;23581:6;23564:56;;;;;;;;;;;;;;;;::::0;:12:::2;;:16;;:56;;;;;:::i;:::-;23549:12;:71;;;;23635:22;23650:6;23635:22;;;;;;:::i;:::-;;;;;;;;23667:41;23694:5;;;;;;;;;;;23701:6;23667:13;;;;;;;;;;;:26;;;;:41;;;;;:::i;:::-;23725:4;23718:11;;915:1:2::1;23431:305:1::0;;;:::o;8262:126::-;8318:17;;:::i;:::-;8354:21;8364:10;8354:9;:21::i;:::-;:27;;8347:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8262:126;;;:::o;871:102::-;934:7;960:6;953:13;;871:102;:::o;22245:1024::-;22331:12;863:5:2;;;;;;;;;;;849:19;;:10;:19;;;841:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;22355:20:1::1;22378:21;22388:10;22378:9;:21::i;:::-;22355:44;;22452:1;22444:10:::0;::::1;22417:6;:18;;:23;;;:37;22409:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;22498:6;:18;;:37;;;;;;;;;;;;22490:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;22574:32;22609:6;:18;;:43;;;22574:78;;22689:24;22670:16;:14;:16::i;:::-;:43;22662:102;;;;;;;;;;;;:::i;:::-;;;;;;;;;22774:26;22803:38;22816:24;22803:12;:38::i;:::-;22774:67;;22889:1;22881:10:::0;::::1;22859:18;:32;;22851:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;23017:6;:18;;:29;;;22995:10;23007:4;22978:34;;;;;;;;;:::i;:::-;;;;;;;;;;;;;22968:45;;;;;;:78;22960:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;23073:15;23118:18;23138:4;23101:42;;;;;;;;;:::i;:::-;;;;;;;;;;;;;23091:53;;;;;;23073:71;;23180:7;23154:6;:18;;:23;;:33;;;;23215:10;23202:39;23227:4;23233:7;23202:39;;;;;;;:::i;:::-;;;;;;;;23258:4;23251:11;;;;;;22245:1024:::0;;;;:::o;14778:1692::-;14879:12;14862:6;37123:1;37114:6;:10;37106:45;;;;;;;;;;;;:::i;:::-;;;;;;;;;14903:14:::1;:12;:14::i;:::-;14927:19;14949:10;14927:32;;14969:20;14992:21;15002:10;14992:9;:21::i;:::-;14969:44;;15053:14;:12;:14::i;:::-;15031:6;:12;;:19;;;:36;15023:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;15101:22;15126:50;15169:6;15126;:18;;:38;;;:42;;:50;;;;:::i;:::-;15101:75;;15186:23;15212:6;:14;;15186:40;;15236:21;15260:7;:14;;;;15236:38;;15284:37;15324:6;:20;;15284:60;;15354:15;15372:65;15398:18;:23;;;15423:13;15372:18;:25;;:65;;;;;:::i;:::-;15354:83;;15447:7;15473:253;;;;;;;;15505:4;15473:253;;;;;;15535:6;15473:253;;;;15565:6;:18;;:38;;;15473:253;;;;15630:7;15473:253;;;;15659:14;15473:253;;;;15700:11;15473:253;;;;::::0;15447:289:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15787:14;15746:6;:18;;:38;;:55;;;;15839:14;15811:6;:12;;:25;;:42;;;;15863;15908:6;:19;;:32;15928:11;15908:32;;;;;;;;;;;;;;;15863:77;;15983:42;16018:6;15983:17;:30;;;:34;;:42;;;;:::i;:::-;15950:17;:30;;:75;;;;16040:17;:24;;;;;;;;;;;;16035:144;;16107:4;16080:17;:24;;;:31;;;;;;;;;;;;;;;;;;16125:6;:12;;:25;;16156:11;16125:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16035:144;16188:19;16210:18;16221:6;16210;:10;;:18;;;;:::i;:::-;16188:40;;16253:29;16270:11;16253:12;;:16;;:29;;;;:::i;:::-;16238:12;:44;;;;16339:13;16326:11;16297:64;;16314:10;16297:64;16354:6;16297:64;;;;;;:::i;:::-;;;;;;;;16371:71;16402:11;16423:4;16430:11;16371:13;;;;;;;;;;;:30;;;;:71;;;;;;:::i;:::-;16459:4;16452:11;;;;;;;;;;;14778:1692:::0;;;;;:::o;98:29:2:-;;;;;;;;;;;;:::o;7385:90:1:-;7430:6;7455:13;;;;;;;;;;;7448:20;;7385:90;:::o;417:236:2:-;462:12;508:14;;;;;;;;;;;494:28;;:10;:28;;;486:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;563:25;573:14;;;;;;;;;;563:9;:25::i;:::-;623:1;598:14;;:27;;;;;;;;;;;;;;;;;;642:4;635:11;;417:236;:::o;643:101:1:-;705:7;731:6;724:13;;643:101;:::o;19399:675::-;19492:12;863:5:2;;;;;;;;;;;849:19;;:10;:19;;;841:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;19516:20:1::1;19539:21;19549:10;19539:9;:21::i;:::-;19516:44;;19579:6;:18;;:37;;;;;;;;;;;;19578:38;19570:79;;;;;;;;;;;;:::i;:::-;;;;;;;;;19690:14;:12;:14::i;:::-;19667:6;:12;;:19;;;:37;;19659:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;19774:4;19734:6;:18;;:37;;;:44;;;;;;;;;;;;;;;;;;19820:10;19788:6;:18;;:29;;:42;;;;19840:28;19890:1;19871:16;:14;:16::i;:::-;:20;19840:51;;19947:20;19901:6;:18;;:43;;:66;;;;20001:10;19982:64;20013:10;20025:20;19982:64;;;;;;;:::i;:::-;;;;;;;;20063:4;20056:11;;;;19399:675:::0;;;;:::o;7194:89::-;7238:7;7264:12;;7257:19;;7194:89;:::o;13630:895::-;13672:12;13696:17;13716:14;:12;:14::i;:::-;13696:34;;13740:20;13763:6;:13;;;;13740:36;;13786:6;:13;;;;;;;;;;;;;;;;;;;;;;;13809:22;13834:6;13841:12;13834:20;;;;;;;;;;;;;;;;;;13809:45;;13864:27;13894:6;13901:19;13918:1;13901:12;:16;;:19;;;;:::i;:::-;13894:27;;;;;;;;;;;;;;;;;;13864:57;;13931:22;13963:20;13986:13;:11;:13::i;:::-;13963:36;;14043:9;14013:13;:19;;:26;;;:39;14009:336;;14071:44;14102:12;14071:13;:19;;:26;;;:30;;:44;;;;:::i;:::-;14054:61;;14009:336;;;14144:24;14171:59;14217:12;14171:41;14185:13;:19;;:26;;;14171:9;:13;;:41;;;;:::i;:::-;:45;;:59;;;;:::i;:::-;14144:86;;14261:73;14292:41;14320:12;14292:23;14313:1;14292:16;:20;;:23;;;;:::i;:::-;:27;;:41;;;;:::i;:::-;14261:13;:19;;:26;;;:30;;:73;;;;:::i;:::-;14244:90;;14009:336;;14378:14;14354:8;:14;;:21;;:38;;;;14423:12;14407:45;14437:14;14407:45;;;;;;:::i;:::-;;;;;;;;14485:12;14462:8;:14;;:20;;:35;;;;14514:4;14507:11;;;;;;;;13630:895;:::o;133:20:2:-;;;;;;;;;;;;;:::o;7577:90:1:-;7622:6;7647:13;;;;;;;;;;;7640:20;;7577:90;:::o;23871:842::-;23934:12;23958:14;23975:10;23958:27;;23995:20;24018:21;24028:10;24018:9;:21::i;:::-;23995:44;;24049:36;24088:6;:19;;:27;24108:6;24088:27;;;;;;;;;;;;;;;24049:66;;24133:11;:18;;;;;;;;;;;;24125:49;;;;;;;;;;;;:::i;:::-;;;;;;;;;24193:11;:22;;;;;;;;;;;;24192:23;24184:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;24255:14;24272:11;:18;;;24255:35;;24317:1;24308:6;:10;24300:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;24407:6;24371;:12;;:32;;;:42;;24363:84;;;;;;;;;;;;:::i;:::-;;;;;;;;;24482:4;24457:11;:22;;;:29;;;;;;;;;;;;;;;;;;24531:44;24568:6;24531;:12;;:32;;;:36;;:44;;;;:::i;:::-;24496:6;:12;;:32;;:79;;;;24618:6;24590:43;;24606:10;24590:43;24626:6;24590:43;;;;;;:::i;:::-;;;;;;;;24643:42;24670:6;24678;24643:13;;;;;;;;;;;:26;;;;:42;;;;;:::i;:::-;24702:4;24695:11;;;;;;23871:842;;;:::o;7729:90::-;7773:7;7799:6;:13;;;;7792:20;;7729:90;:::o;18024:1019::-;18088:12;18112:20;18135:21;18145:10;18135:9;:21::i;:::-;18112:44;;18166:19;18188:16;:14;:16::i;:::-;18166:38;;18257:1;18249:10;;18222:6;:18;;:23;;;:37;18214:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;18295:14;18312:6;:12;;:19;;;18295:36;;18345:6;:18;;:37;;;;;;;;;;;;18341:471;;;18398:19;18434:6;:18;;:43;;;18420:11;:57;18398:79;;18491:18;18581:1;18573:10;;18512:57;18525:6;:18;;:43;;;18512:12;:57::i;:::-;:71;;18491:92;;18605:14;:32;;;;;18624:13;18623:14;18605:32;18597:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;18341:471;;;;;18759:14;:12;:14::i;:::-;18721:35;18732:23;:21;:23::i;:::-;18721:6;:10;;:35;;;;:::i;:::-;:52;18713:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;18341:471;18862:4;18822:6;:18;;:37;;;:44;;;;;;;;;;;;;;;;;;18876:12;18891:32;18904:18;18920:1;18904:11;:15;;:18;;;;:::i;:::-;18891:12;:32::i;:::-;18876:47;;18959:4;18933:6;:18;;:23;;:30;;;;18998:10;18978:37;19010:4;18978:37;;;;;;:::i;:::-;;;;;;;;19032:4;19025:11;;;;;;18024:1019;;;:::o;9596:856::-;9701:12;9727;9753:22;9789:14;9817:38;9880:20;9903:21;9913:10;9903:9;:21::i;:::-;9880:44;;9934:23;9960:6;:20;;9934:46;;9997:4;:9;;;9990:16;;10023:4;:9;;;10016:16;;10059:4;:7;;;10042:24;;10085:4;:11;;;10076:20;;10144:6;10115:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;10106:45;;10161:10;10174:4;:9;;;10161:22;;10198:13;10193:253;10225:6;10217:5;:14;10193:253;;;10259:22;;:::i;:::-;10284:16;10297:2;10284:4;:12;;:16;;;;:::i;:::-;10259:41;;10330:77;;;;;;;;10361:6;:14;;10376:4;:10;;;10361:26;;;;;;;;;;;;;;;;;;10330:77;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10401:4;10330:77;;;10314:6;10321:5;10314:13;;;;;;;;;;;;;:93;;;;10426:4;:9;;;10421:14;;10193:253;10242:1;10233:10;;;;10193:253;;;;9596:856;;;;;;;;;;:::o;20461:1337::-;20557:12;20581:14;:12;:14::i;:::-;20605:17;20625:14;:12;:14::i;:::-;20605:34;;20649:33;20685:25;20695:14;20685:9;:25::i;:::-;:31;;20649:67;;20767:1;20730:14;:27;;:34;;;;:38;20726:366;;;20792:14;:21;;;;;;;;;;;;20784:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;20853:20;20876:53;20904:24;:22;:24::i;:::-;20876:14;:23;;;:27;;:53;;;;:::i;:::-;20853:76;;20964:12;20951:9;:25;;20943:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;20726:366;;;;21051:14;:21;;;21038:9;:34;;21030:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;20726:366;21102:20;21125:14;:34;;;21102:57;;21192:1;21177:12;:16;21169:45;;;;;;;;;;;;:::i;:::-;;;;;;;;;21224:31;21258:23;21268:12;21258:9;:23::i;:::-;:29;;21224:63;;21317:12;:19;;;21305:9;:31;21297:66;;;;;;;;;;;;:::i;:::-;;;;;;;;;21394:30;21404:19;21421:1;21404:12;:16;;:19;;;;:::i;:::-;21394:9;:30::i;:::-;:36;;:43;;;21381:9;:56;;21373:105;;;;;;;;;;;;:::i;:::-;;;;;;;;;21525:1;21488:14;:34;;:38;;;;21563:42;21592:12;21563;:24;;;:28;;:42;;;;:::i;:::-;21536:12;:24;;:69;;;;21650:50;21687:12;21650;:32;;;:36;;:50;;;;:::i;:::-;21615:12;:32;;:85;;;;21757:12;21741:14;21715:55;;;;;;;;;;21787:4;21780:11;;;;;;20461:1337;;;;:::o;12463:1127::-;12650:12;12690:1;12682:5;:9;12674:40;;;;;;;;;;;;:::i;:::-;;;;;;;;;12724:20;12747:21;12757:10;12747:9;:21::i;:::-;12724:44;;12821:1;12813:10;;12786:6;:18;;:23;;;:37;;12778:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;12864:6;:12;;:19;;;;;;;;;;;;12863:20;12855:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;12965:6;:18;;:39;;;12940:21;:64;;12932:105;;;;;;;;;;;;:::i;:::-;;;;;;;;;13084:1;13051:6;:18;;:29;;;:34;13047:434;;;13377:6;:18;;:39;;;13325:49;13352:21;13325:15;:22;:26;;:49;;;;:::i;:::-;:91;13300:170;;;;;;;;;;;;:::i;:::-;;;;;;;;;13047:434;13490:72;13508:6;13516:15;13533:21;13556:5;13490:17;:72::i;:::-;13579:4;13572:11;;;12463:1127;;;;;;:::o;24819:236::-;24862:22;24887:20;24905:1;24887:6;:13;;;;:17;;:20;;;;:::i;:::-;24862:45;;24959:14;:12;:14::i;:::-;24921:6;24928:14;24921:22;;;;;;;;;;;;;;;;;;:28;;:35;;;:52;24917:65;;;24975:7;;;24917:65;25007:14;24996:26;;;;;;;;;;25032:16;:14;:16::i;:::-;;24819:236;;:::o;25242:167::-;25298:13;25339:6;:13;;;;25331:5;:21;25323:49;;;;;;;;;;;;:::i;:::-;;;;;;;;;25389:6;25396:5;25389:13;;;;;;;;;;;;;;;;;;25382:20;;25242:167;;;:::o;1478:103::-;1533:7;1559:15;1552:22;;1478:103;:::o;882:176:4:-;940:7;959:9;975:1;971;:5;959:17;;999:1;994;:6;;986:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;1050:1;1043:8;;;882:176;;;;:::o;885:203:6:-;985:96;1005:5;1035:27;;;1064:4;1070:2;1074:5;1012:68;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;985:19;:96::i;:::-;885:203;;;;:::o;929:129:2:-;1008:6;991:14;;:23;;;;;;;;;;;;;;;;;;1044:6;1029:22;;;;;;;;;;;;929:129;:::o;1754:187:4:-;1840:7;1872:1;1867;:6;;1875:12;1859:29;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;1898:9;1914:1;1910;:5;1898:17;;1933:1;1926:8;;;1754:187;;;;;:::o;704:175:6:-;786:86;806:5;836:23;;;861:2;865:5;813:58;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;786:19;:86::i;:::-;704:175;;;:::o;1250:102:1:-;1307:7;1333:12;1326:19;;1250:102;:::o;1682:129::-;1756:7;1792:11;1782:22;1775:29;;1682:129;;;:::o;316:844:0:-;444:15;471:23;497:4;:8;;:24;506:14;497:24;;;;;;;;;;;471:50;;539:4;:11;;;;;;;;;;;;:34;;;;572:1;554:14;:19;539:34;531:86;;;;;;;;;;;;:::i;:::-;;;;;;;;;638:1;627:4;:7;;;:12;;;;;;;;;;;649:26;678:4;:8;;:17;687:4;:7;;;678:17;;;;;;;;;;;649:46;;722:4;705:7;:14;;;:21;;;;;;;;;;;;;;;;;;752:5;736:7;:13;;:21;;;;782:14;767:7;:12;;:29;;;;839:1;821:14;:19;:43;;855:4;:9;;;821:43;;;843:4;:9;;;821:43;806:7;:12;;:58;;;;886:4;:7;;;874:4;:9;;:19;;;;933:4;:7;;;903:4;:8;;:22;912:7;:12;;;903:22;;;;;;;;;;;:27;;:37;;;;980:4;:7;;;950:4;:8;;:22;959:7;:12;;;950:22;;;;;;;;;;;:27;;:37;;;;1019:1;1001:14;:19;997:44;;;1034:4;:7;;;1022:4;:9;;:19;;;;997:44;1073:4;:9;;;1055:14;:27;1051:52;;;1096:4;:7;;;1084:4;:9;;:19;;;;1051:52;1128:1;1113:4;:11;;;:16;;;;;;;;;;;1146:4;:7;;;1139:14;;;;316:844;;;;;:::o;2188:459:4:-;2246:7;2492:1;2487;:6;2483:45;;;2516:1;2509:8;;;;2483:45;2538:9;2554:1;2550;:5;2538:17;;2582:1;2577;2573;:5;;;;;;:10;2565:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;2639:1;2632:8;;;2188:459;;;;;:::o;1064:116:2:-;1128:8;1120:5;;:16;;;;;;;;;;;;;;;;;;1164:8;1151:22;;;;;;;;;;;;1064:116;:::o;1329:134:4:-;1387:7;1413:43;1417:1;1420;1413:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;1406:50;;1329:134;;;;:::o;3109:130::-;3167:7;3193:39;3197:1;3200;3193:39;;;;;;;;;;;;;;;;;:3;:39::i;:::-;3186:46;;3109:130;;;;:::o;1889:256:0:-;1971:17;;:::i;:::-;2000:23;2026:4;:8;;:17;2035:7;2026:17;;;;;;;;;;;2000:43;;2061:4;:11;;;;;;;;;;;;2053:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;2134:4;2127:11;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1889:256;;;;:::o;25799:3075:1:-;25984:29;26016:6;:18;;:40;;;25984:72;;26109:28;26135:1;26109:21;:25;;:28;;;;:::i;:::-;26066:6;:18;;:40;;:71;;;;26322:1;26290:6;:18;;:29;;;:33;26286:306;;;26377:19;26389:6;26377:11;:19::i;:::-;26482:1;26474:5;:9;26470:91;;;26485:76;26503:6;26511:15;26528:21;26559:1;26551:5;:9;26485:17;:76::i;:::-;26470:91;26575:7;;;26286:306;26678:14;26730:6;:18;;:23;;;26755:21;26713:64;;;;;;;;;:::i;:::-;;;;;;;;;;;;;26703:75;;;;;;26695:84;;26678:101;;26789:28;26820:6;:18;;:39;;;26789:70;;27018:20;26965:49;26992:21;26965:15;:22;:26;;:49;;;;:::i;:::-;:73;26961:86;;27040:7;;;;;26961:86;27144:50;27155:6;:18;;:38;;;27144:6;:10;;:50;;;;:::i;:::-;27135:59;;27243:37;27283:15;27299:47;27324:21;27299:20;:24;;:47;;;;:::i;:::-;27283:64;;;;;;;;;;;;;;27243:104;;27397:6;:14;;:21;;;;27365:29;:53;27357:94;;;;;;;;;;;;:::i;:::-;;;;;;;;;27461:38;27502:6;:14;;27517:29;27502:45;;;;;;;;;;;;;;;;;;27461:86;;27599:27;27624:1;27599:20;:24;;:27;;;;:::i;:::-;27557:6;:18;;:39;;:69;;;;27727:24;:31;;;;;;;;;;;;27719:78;;;;;;;;;;;;:::i;:::-;;;;;;;;;27909:6;27876:24;:29;;;:39;;:79;;;;;27949:6;27919:24;:27;;;:36;27876:79;27855:157;;;;;;;;;;;;:::i;:::-;;;;;;;;;28022:33;28058:24;:32;;;;;;;;;;;;28022:68;;28100:42;28145:6;:19;;:46;28165:25;28145:46;;;;;;;;;;;;;;;28100:91;;28245:17;:24;;;;;;;;;;;;28240:475;;28315:16;28334:68;28349:6;28357:17;28376:25;28334:14;:68::i;:::-;28315:87;;28515:11;28511:24;;;28528:7;;;;;;;;;;28511:24;28240:475;;;;28672:24;:32;;;28640:6;:18;;:29;;:64;;;;28240:475;28788:1;28780:5;:9;28776:91;;;28791:76;28809:6;28817:15;28834:21;28865:1;28857:5;:9;28791:17;:76::i;:::-;28776:91;25799:3075;;;;;;;;;;;;:::o;2967:751:6:-;3386:23;3412:69;3440:4;3412:69;;;;;;;;;;;;;;;;;3420:5;3412:27;;;;:69;;;;;:::i;:::-;3386:95;;3515:1;3495:10;:17;:21;3491:221;;;3635:10;3624:30;;;;;;;;;;;;:::i;:::-;3616:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;3491:221;2967:751;;;:::o;3721:272:4:-;3807:7;3838:1;3834;:5;3841:12;3826:28;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;3864:9;3880:1;3876;:5;;;;;;3864:17;;3985:1;3978:8;;;3721:272;;;;;:::o;30399:3512:1:-;30460:23;30486:6;:20;;30460:46;;30516:22;30541:19;30550:4;:9;;;30541:4;:8;;:19;;;;:::i;:::-;30516:44;;30570:23;30596:6;:14;;30611;30596:30;;;;;;;;;;;;;;;;;;30570:56;;30636:25;;:::i;:::-;30664:43;30677:6;:18;;:29;;;30664:4;:12;;:43;;;;:::i;:::-;30636:71;;30717:17;30737:6;:14;;30752:7;:13;;;30737:29;;;;;;;;;;;;;;;;;;30717:49;;30858:6;:18;;:29;;;30845:4;:9;;;:42;30841:364;;;30979:60;31022:9;:16;;;30979:6;:18;;:38;;;:42;;:60;;;;:::i;:::-;30938:6;:18;;:38;;:101;;;;31053:42;31065:6;:18;;:29;;;31053:4;:11;;:42;;;;:::i;:::-;31141:1;31109:6;:18;;:29;;:33;;;;31169:5;31156:3;:10;;;:18;;;;;;;;;;;;;;;;;;31188:7;;;;;;;30841:364;31214:40;31257:6;:19;;:38;31277:9;:17;;;;;;;;;;;;31257:38;;;;;;;;;;;;;;;31214:81;;31378:15;:22;;;;;;;;;;;;31374:323;;;31532:60;31575:9;:16;;;31532:6;:18;;:38;;;:42;;:60;;;;:::i;:::-;31491:6;:18;;:38;;:101;;;;31606:22;31618:4;:9;;;31606:4;:11;;:22;;;;:::i;:::-;31661:5;31642:9;:16;;;:24;;;;;;;;;;;;;;;;;;31680:7;;;;;;;;31374:323;31941:22;31966:38;31975:3;:10;;;31987:9;:16;;;31966:8;:38::i;:::-;31941:63;;32055:58;32098:14;32055:6;:18;;:38;;;:42;;:58;;;;:::i;:::-;32014:6;:18;;:38;;:99;;;;32142:1;32127:7;:12;;;:16;32123:477;;;32159:23;32185:6;:14;;32200:22;32209:7;:12;;;32200:4;:8;;:22;;;;:::i;:::-;32185:38;;;;;;;;;;;;;;;;;;32159:64;;32262:9;:17;;;;;;;;;;;;32241:38;;:9;:17;;;;;;;;;;;;:38;;;32237:353;;;32491:84;32519:6;32527:9;32538:3;32543:9;32554:14;32570:4;32491:27;:84::i;:::-;32484:91;;;;;;;;;;32237:353;32123:477;;32628:1;32613:7;:12;;;:16;:45;;;;;32649:4;:9;;;32633:7;:12;;;:25;;32613:45;32609:504;;;32674:23;32700:6;:14;;32715:22;32724:7;:12;;;32715:4;:8;;:22;;;;:::i;:::-;32700:38;;;;;;;;;;;;;;;;;;32674:64;;32777:9;:17;;;;;;;;;;;;32756:38;;:9;:17;;;;;;;;;;;;:38;;;32752:351;;;33004:84;33032:6;33040:9;33051:3;33056:9;33067:14;33083:4;33004:27;:84::i;:::-;32997:91;;;;;;;;;;32752:351;32609:504;;33289:21;33313:6;:14;;:21;;;;33289:45;;33344:20;33367:3;:8;;;33344:31;;33396:28;33409:14;33396:3;:8;;;:12;;:28;;;;:::i;:::-;33385:3;:8;;:39;;;;33447:30;33462:14;33447:3;:10;;;:14;;:30;;;;:::i;:::-;33434:3;:10;;:43;;;;33506:36;33527:14;33506:9;:16;;;:20;;:36;;;;:::i;:::-;33487:9;:16;;:55;;;;33567:32;33584:14;33567:9;:12;;;:16;;:32;;;;:::i;:::-;33552:9;:12;;:47;;;;33609:15;33627:40;33639:7;:12;;;33653:13;33627:4;:11;;:40;;;;;:::i;:::-;33609:58;;33677:6;:14;;33697:79;;;;;;;;33703:4;33697:79;;;;;;33709:14;33697:79;;;;33725:12;33697:79;;;;33739:7;33697:79;;;;33748:3;:8;;;33697:79;;;;33758:9;:17;;;;;;;;;;;;33697:79;;;;;33677:100;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33856:48;33875:6;33883:3;33888:9;33899:4;33856:18;:48::i;:::-;30399:3512;;;;;;;;;;;;:::o;4444:128:4:-;4502:7;4528:37;4532:1;4535;4528:37;;;;;;;;;;;;;;;;;:3;:37::i;:::-;4521:44;;4444:128;;;;:::o;29175:1106:1:-;29347:16;29375:14;29392:73;29421:14;29436:6;:12;;:20;;:27;;;;29421:43;;;;;;;;;29392:6;:12;;:24;;;:28;;:73;;;;:::i;:::-;29375:90;;29502:6;29475:17;:24;;:33;;;;29545:4;29518:17;:24;;;:31;;;;;;;;;;;;;;;;;;29559:6;:12;;:20;;29585:25;29559:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29621:33;29657:6;:12;;:20;;:27;;;;29621:63;;29733:25;29699:68;;29713:6;:12;;:18;;;29699:68;29760:6;29699:68;;;;;;:::i;:::-;;;;;;;;29890:1;29861:25;:30;;:95;;;;29924:6;:12;;:25;;:32;;;;29895:25;:61;;29861:95;29857:351;;;30016:6;:12;;:18;;;30004:31;;;;;;;;;;30071:4;30049:6;:12;;:19;;;:26;;;;;;;;;;;;;;;;;;30113:14;:12;:14::i;:::-;30089:6;:12;;:21;;:38;;;;30193:4;30186:11;;;;;;29857:351;30269:5;30262:12;;;;29175:1106;;;;;;:::o;3581:193:7:-;3684:12;3715:52;3737:6;3745:4;3751:1;3754:12;3715:21;:52::i;:::-;3708:59;;3581:193;;;;;:::o;1633:250:0:-;1711:13;1736:23;1762:4;:8;;:17;1771:7;1762:17;;;;;;;;;;;1736:43;;1797:4;:11;;;;;;;;;;;;1789:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;1866:4;:10;;;1859:17;;;1633:250;;;;:::o;1166:461::-;1243:23;1269:4;:8;;:17;1278:7;1269:17;;;;;;;;;;;1243:43;;1304:4;:11;;;;;;;;;;;;1296:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;1383:5;1369:4;:11;;;:19;;;;;;;;;;;;;;;;;;1425:4;:9;;;1398:4;:8;;:19;1407:4;:9;;;1398:19;;;;;;;;;;;:24;;:36;;;;1471:4;:9;;;1444:4;:8;;:19;1453:4;:9;;;1444:19;;;;;;;;;;;:24;;:36;;;;1507:7;1494:4;:9;;;:20;1490:47;;;1528:4;:9;;;1516:4;:9;;:21;;;;1490:47;1564:7;1551:4;:9;;;:20;1547:47;;;1585:4;:9;;;1573:4;:9;;:21;;;;1547:47;1619:1;1604:4;:11;;;:16;;;;;;;;;;;1166:461;;;:::o;399:104:3:-;457:7;487:1;483;:5;:13;;495:1;483:13;;;491:1;483:13;476:20;;399:104;;;;:::o;34299:634:1:-;34567:36;34588:14;34567:9;:16;;;:20;;:36;;;;:::i;:::-;34548:9;:16;;:55;;;;34628:32;34645:14;34628:9;:12;;;:16;;:32;;;;:::i;:::-;34613:9;:12;;:47;;;;34681:9;:12;;;34670:3;:8;;:23;;;;34716:30;34731:14;34716:3;:10;;;:14;;:30;;;;:::i;:::-;34703:3;:10;;:43;;;;34771:32;34788:14;34771:9;:12;;;:16;;:32;;;;:::i;:::-;34756:9;:12;;:47;;;;34832:36;34853:14;34832:9;:16;;;:20;;:36;;;;:::i;:::-;34813:9;:16;;:55;;;;34878:48;34897:6;34905:3;34910:9;34921:4;34878:18;:48::i;:::-;34299:634;;;;;;:::o;35319:638::-;35587:36;35608:14;35587:9;:16;;;:20;;:36;;;;:::i;:::-;35568:9;:16;;:55;;;;35650:34;35669:14;35650:9;:14;;;:18;;:34;;;;:::i;:::-;35633:9;:14;;:51;;;;35703:9;:14;;;35694:3;:6;;:23;;;;35740:30;35755:14;35740:3;:10;;;:14;;:30;;;;:::i;:::-;35727:3;:10;;:43;;;;35795:32;35812:14;35795:9;:12;;;:16;;:32;;;;:::i;:::-;35780:9;:12;;:47;;;;35856:36;35877:14;35856:9;:16;;;:20;;:36;;;;:::i;:::-;35837:9;:16;;:55;;;;35902:48;35921:6;35929:3;35934:9;35945:4;35902:18;:48::i;:::-;35319:638;;;;;;:::o;36192:767::-;36497:1;36483:3;:10;;;:15;36479:255;;;36570:5;36557:3;:10;;;:18;;;;;;;;;;;;;;;;;;36589:42;36601:6;:18;;:29;;;36589:4;:11;;:42;;;;:::i;:::-;36722:1;36690:6;:18;;:29;;:33;;;;36479:255;36840:1;36820:9;:16;;;:21;36816:137;;;36901:5;36882:9;:16;;;:24;;;;;;;;;;;;;;;;;;36920:22;36932:4;:9;;;36920:4;:11;;:22;;;;:::i;:::-;36816:137;36192:767;;;;:::o;5043:163:4:-;5129:7;5161:1;5156;:6;;5164:12;5148:29;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;5198:1;5194;:5;;;;;;5187:12;;5043:163;;;;;:::o;4608:523:7:-;4735:12;4792:5;4775:4;4767:21;;;:30;;4759:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;4858:18;4869:6;4858:10;:18::i;:::-;4850:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;4981:12;4995:23;5022:6;:11;;5042:5;5050:4;5022:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4980:75;;;;5072:52;5090:7;5099:10;5111:12;5072:17;:52::i;:::-;5065:59;;;;4608:523;;;;;;:::o;726:413::-;786:4;989:12;1098:7;1086:20;1078:28;;1131:1;1124:4;:8;1117:15;;;726:413;;;:::o;6111:725::-;6226:12;6254:7;6250:580;;;6284:10;6277:17;;;;6250:580;6415:1;6395:10;:17;:21;6391:429;;;6653:10;6647:17;6713:15;6700:10;6696:2;6692:19;6685:44;6602:145;6792:12;6785:20;;;;;;;;;;;:::i;:::-;;;;;;;;6111:725;;;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;5:130::-;;85:6;72:20;63:29;;97:33;124:5;97:33;:::i;:::-;57:78;;;;:::o;160:707::-;;277:3;270:4;262:6;258:17;254:27;244:2;;295:1;292;285:12;244:2;332:6;319:20;354:80;369:64;426:6;369:64;:::i;:::-;354:80;:::i;:::-;345:89;;451:5;476:6;469:5;462:21;506:4;498:6;494:17;484:27;;528:4;523:3;519:14;512:21;;581:6;628:3;620:4;612:6;608:17;603:3;599:27;596:36;593:2;;;645:1;642;635:12;593:2;670:1;655:206;680:6;677:1;674:13;655:206;;;738:3;760:37;793:3;781:10;760:37;:::i;:::-;755:3;748:50;821:4;816:3;812:14;805:21;;849:4;844:3;840:14;833:21;;712:149;702:1;699;695:9;690:14;;655:206;;;659:14;237:630;;;;;;;:::o;875:128::-;;956:6;950:13;941:22;;968:30;992:5;968:30;:::i;:::-;935:68;;;;:::o;1010:130::-;;1090:6;1077:20;1068:29;;1102:33;1129:5;1102:33;:::i;:::-;1062:78;;;;:::o;1147:130::-;;1227:6;1214:20;1205:29;;1239:33;1266:5;1239:33;:::i;:::-;1199:78;;;;:::o;1284:241::-;;1388:2;1376:9;1367:7;1363:23;1359:32;1356:2;;;1404:1;1401;1394:12;1356:2;1439:1;1456:53;1501:7;1492:6;1481:9;1477:22;1456:53;:::i;:::-;1446:63;;1418:97;1350:175;;;;:::o;1532:257::-;;1644:2;1632:9;1623:7;1619:23;1615:32;1612:2;;;1660:1;1657;1650:12;1612:2;1695:1;1712:61;1765:7;1756:6;1745:9;1741:22;1712:61;:::i;:::-;1702:71;;1674:105;1606:183;;;;:::o;1796:241::-;;1900:2;1888:9;1879:7;1875:23;1871:32;1868:2;;;1916:1;1913;1906:12;1868:2;1951:1;1968:53;2013:7;2004:6;1993:9;1989:22;1968:53;:::i;:::-;1958:63;;1930:97;1862:175;;;;:::o;2044:366::-;;;2165:2;2153:9;2144:7;2140:23;2136:32;2133:2;;;2181:1;2178;2171:12;2133:2;2216:1;2233:53;2278:7;2269:6;2258:9;2254:22;2233:53;:::i;:::-;2223:63;;2195:97;2323:2;2341:53;2386:7;2377:6;2366:9;2362:22;2341:53;:::i;:::-;2331:63;;2302:98;2127:283;;;;;:::o;2417:753::-;;;;;2597:3;2585:9;2576:7;2572:23;2568:33;2565:2;;;2614:1;2611;2604:12;2565:2;2649:1;2666:53;2711:7;2702:6;2691:9;2687:22;2666:53;:::i;:::-;2656:63;;2628:97;2784:2;2773:9;2769:18;2756:32;2808:18;2800:6;2797:30;2794:2;;;2840:1;2837;2830:12;2794:2;2860:78;2930:7;2921:6;2910:9;2906:22;2860:78;:::i;:::-;2850:88;;2735:209;2975:2;2993:53;3038:7;3029:6;3018:9;3014:22;2993:53;:::i;:::-;2983:63;;2954:98;3083:2;3101:53;3146:7;3137:6;3126:9;3122:22;3101:53;:::i;:::-;3091:63;;3062:98;2559:611;;;;;;;:::o;3177:366::-;;;3298:2;3286:9;3277:7;3273:23;3269:32;3266:2;;;3314:1;3311;3304:12;3266:2;3349:1;3366:53;3411:7;3402:6;3391:9;3387:22;3366:53;:::i;:::-;3356:63;;3328:97;3456:2;3474:53;3519:7;3510:6;3499:9;3495:22;3474:53;:::i;:::-;3464:63;;3435:98;3260:283;;;;;:::o;3550:366::-;;;3671:2;3659:9;3650:7;3646:23;3642:32;3639:2;;;3687:1;3684;3677:12;3639:2;3722:1;3739:53;3784:7;3775:6;3764:9;3760:22;3739:53;:::i;:::-;3729:63;;3701:97;3829:2;3847:53;3892:7;3883:6;3872:9;3868:22;3847:53;:::i;:::-;3837:63;;3808:98;3633:283;;;;;:::o;3924:173::-;;4011:46;4053:3;4045:6;4011:46;:::i;:::-;4086:4;4081:3;4077:14;4063:28;;4004:93;;;;:::o;4106:331::-;;4271:124;4391:3;4383:6;4271:124;:::i;:::-;4424:6;4419:3;4415:16;4401:30;;4264:173;;;;:::o;4446:261::-;;4577:90;4663:3;4655:6;4577:90;:::i;:::-;4696:4;4691:3;4687:14;4673:28;;4570:137;;;;:::o;4715:184::-;4832:61;4860:32;4886:5;4860:32;:::i;:::-;4832:61;:::i;:::-;4827:3;4820:74;4814:85;;:::o;4906:103::-;4979:24;4997:5;4979:24;:::i;:::-;4974:3;4967:37;4961:48;;:::o;5016:113::-;5099:24;5117:5;5099:24;:::i;:::-;5094:3;5087:37;5081:48;;:::o;5167:670::-;;5302:54;5350:5;5302:54;:::i;:::-;5369:76;5438:6;5433:3;5369:76;:::i;:::-;5362:83;;5466:56;5516:5;5466:56;:::i;:::-;5542:7;5570:1;5555:260;5580:6;5577:1;5574:13;5555:260;;;5647:6;5641:13;5668:63;5727:3;5712:13;5668:63;:::i;:::-;5661:70;;5748:60;5801:6;5748:60;:::i;:::-;5738:70;;5612:203;5602:1;5599;5595:9;5590:14;;5555:260;;;5559:14;5828:3;5821:10;;5281:556;;;;;;;:::o;5952:1002::-;;6175:93;6262:5;6175:93;:::i;:::-;6281:125;6399:6;6394:3;6281:125;:::i;:::-;6274:132;;6427:95;6516:5;6427:95;:::i;:::-;6542:7;6570:1;6555:377;6580:6;6577:1;6574:13;6555:377;;;6647:6;6641:13;6668:141;6805:3;6790:13;6668:141;:::i;:::-;6661:148;;6826:99;6918:6;6826:99;:::i;:::-;6816:109;;6612:320;6602:1;6599;6595:9;6590:14;;6555:377;;;6559:14;6945:3;6938:10;;6154:800;;;;;;;:::o;7035:866::-;;7224:76;7294:5;7224:76;:::i;:::-;7313:108;7414:6;7409:3;7313:108;:::i;:::-;7306:115;;7442:78;7514:5;7442:78;:::i;:::-;7540:7;7568:1;7553:326;7578:6;7575:1;7572:13;7553:326;;;7645:6;7639:13;7666:107;7769:3;7754:13;7666:107;:::i;:::-;7659:114;;7790:82;7865:6;7790:82;:::i;:::-;7780:92;;7610:269;7600:1;7597;7593:9;7588:14;;7553:326;;;7557:14;7892:3;7885:10;;7203:698;;;;;;;:::o;7909:94::-;7976:21;7991:5;7976:21;:::i;:::-;7971:3;7964:34;7958:45;;:::o;8010:104::-;8087:21;8102:5;8087:21;:::i;:::-;8082:3;8075:34;8069:45;;:::o;8121:103::-;8194:24;8212:5;8194:24;:::i;:::-;8189:3;8182:37;8176:48;;:::o;8231:113::-;8314:24;8332:5;8314:24;:::i;:::-;8309:3;8302:37;8296:48;;:::o;8351:152::-;8452:45;8472:24;8490:5;8472:24;:::i;:::-;8452:45;:::i;:::-;8447:3;8440:58;8434:69;;:::o;8510:356::-;;8638:38;8670:5;8638:38;:::i;:::-;8688:88;8769:6;8764:3;8688:88;:::i;:::-;8681:95;;8781:52;8826:6;8821:3;8814:4;8807:5;8803:16;8781:52;:::i;:::-;8854:6;8849:3;8845:16;8838:23;;8618:248;;;;;:::o;8873:156::-;8971:52;9017:5;8971:52;:::i;:::-;8966:3;8959:65;8953:76;;:::o;9036:347::-;;9148:39;9181:5;9148:39;:::i;:::-;9199:71;9263:6;9258:3;9199:71;:::i;:::-;9192:78;;9275:52;9320:6;9315:3;9308:4;9301:5;9297:16;9275:52;:::i;:::-;9348:29;9370:6;9348:29;:::i;:::-;9343:3;9339:39;9332:46;;9128:255;;;;;:::o;9391:371::-;;9551:67;9615:2;9610:3;9551:67;:::i;:::-;9544:74;;9651:34;9647:1;9642:3;9638:11;9631:55;9720:4;9715:2;9710:3;9706:12;9699:26;9753:2;9748:3;9744:12;9737:19;;9537:225;;;:::o;9771:328::-;;9931:67;9995:2;9990:3;9931:67;:::i;:::-;9924:74;;10031:30;10027:1;10022:3;10018:11;10011:51;10090:2;10085:3;10081:12;10074:19;;9917:182;;;:::o;10108:318::-;;10268:67;10332:2;10327:3;10268:67;:::i;:::-;10261:74;;10368:20;10364:1;10359:3;10355:11;10348:41;10417:2;10412:3;10408:12;10401:19;;10254:172;;;:::o;10435:329::-;;10595:67;10659:2;10654:3;10595:67;:::i;:::-;10588:74;;10695:31;10691:1;10686:3;10682:11;10675:52;10755:2;10750:3;10746:12;10739:19;;10581:183;;;:::o;10773:316::-;;10933:67;10997:2;10992:3;10933:67;:::i;:::-;10926:74;;11033:18;11029:1;11024:3;11020:11;11013:39;11080:2;11075:3;11071:12;11064:19;;10919:170;;;:::o;11098:383::-;;11258:67;11322:2;11317:3;11258:67;:::i;:::-;11251:74;;11358:34;11354:1;11349:3;11345:11;11338:55;11427:16;11422:2;11417:3;11413:12;11406:38;11472:2;11467:3;11463:12;11456:19;;11244:237;;;:::o;11490:318::-;;11650:67;11714:2;11709:3;11650:67;:::i;:::-;11643:74;;11750:20;11746:1;11741:3;11737:11;11730:41;11799:2;11794:3;11790:12;11783:19;;11636:172;;;:::o;11817:330::-;;11977:67;12041:2;12036:3;11977:67;:::i;:::-;11970:74;;12077:32;12073:1;12068:3;12064:11;12057:53;12138:2;12133:3;12129:12;12122:19;;11963:184;;;:::o;12156:377::-;;12316:67;12380:2;12375:3;12316:67;:::i;:::-;12309:74;;12416:34;12412:1;12407:3;12403:11;12396:55;12485:10;12480:2;12475:3;12471:12;12464:32;12524:2;12519:3;12515:12;12508:19;;12302:231;;;:::o;12542:324::-;;12702:67;12766:2;12761:3;12702:67;:::i;:::-;12695:74;;12802:26;12798:1;12793:3;12789:11;12782:47;12857:2;12852:3;12848:12;12841:19;;12688:178;;;:::o;12875:327::-;;13035:67;13099:2;13094:3;13035:67;:::i;:::-;13028:74;;13135:29;13131:1;13126:3;13122:11;13115:50;13193:2;13188:3;13184:12;13177:19;;13021:181;;;:::o;13211:331::-;;13371:67;13435:2;13430:3;13371:67;:::i;:::-;13364:74;;13471:33;13467:1;13462:3;13458:11;13451:54;13533:2;13528:3;13524:12;13517:19;;13357:185;;;:::o;13551:371::-;;13711:67;13775:2;13770:3;13711:67;:::i;:::-;13704:74;;13811:34;13807:1;13802:3;13798:11;13791:55;13880:4;13875:2;13870:3;13866:12;13859:26;13913:2;13908:3;13904:12;13897:19;;13697:225;;;:::o;13931:320::-;;14091:67;14155:2;14150:3;14091:67;:::i;:::-;14084:74;;14191:22;14187:1;14182:3;14178:11;14171:43;14242:2;14237:3;14233:12;14226:19;;14077:174;;;:::o;14260:321::-;;14420:67;14484:2;14479:3;14420:67;:::i;:::-;14413:74;;14520:23;14516:1;14511:3;14507:11;14500:44;14572:2;14567:3;14563:12;14556:19;;14406:175;;;:::o;14590:328::-;;14750:67;14814:2;14809:3;14750:67;:::i;:::-;14743:74;;14850:30;14846:1;14841:3;14837:11;14830:51;14909:2;14904:3;14900:12;14893:19;;14736:182;;;:::o;14927:371::-;;15087:67;15151:2;15146:3;15087:67;:::i;:::-;15080:74;;15187:34;15183:1;15178:3;15174:11;15167:55;15256:4;15251:2;15246:3;15242:12;15235:26;15289:2;15284:3;15280:12;15273:19;;15073:225;;;:::o;15307:375::-;;15467:67;15531:2;15526:3;15467:67;:::i;:::-;15460:74;;15567:34;15563:1;15558:3;15554:11;15547:55;15636:8;15631:2;15626:3;15622:12;15615:30;15673:2;15668:3;15664:12;15657:19;;15453:229;;;:::o;15691:321::-;;15851:67;15915:2;15910:3;15851:67;:::i;:::-;15844:74;;15951:23;15947:1;15942:3;15938:11;15931:44;16003:2;15998:3;15994:12;15987:19;;15837:175;;;:::o;16021:322::-;;16181:67;16245:2;16240:3;16181:67;:::i;:::-;16174:74;;16281:24;16277:1;16272:3;16268:11;16261:45;16334:2;16329:3;16325:12;16318:19;;16167:176;;;:::o;16352:373::-;;16512:67;16576:2;16571:3;16512:67;:::i;:::-;16505:74;;16612:34;16608:1;16603:3;16599:11;16592:55;16681:6;16676:2;16671:3;16667:12;16660:28;16716:2;16711:3;16707:12;16700:19;;16498:227;;;:::o;16734:325::-;;16894:67;16958:2;16953:3;16894:67;:::i;:::-;16887:74;;16994:27;16990:1;16985:3;16981:11;16974:48;17050:2;17045:3;17041:12;17034:19;;16880:179;;;:::o;17068:319::-;;17228:67;17292:2;17287:3;17228:67;:::i;:::-;17221:74;;17328:21;17324:1;17319:3;17315:11;17308:42;17378:2;17373:3;17369:12;17362:19;;17214:173;;;:::o;17396:373::-;;17556:67;17620:2;17615:3;17556:67;:::i;:::-;17549:74;;17656:34;17652:1;17647:3;17643:11;17636:55;17725:6;17720:2;17715:3;17711:12;17704:28;17760:2;17755:3;17751:12;17744:19;;17542:227;;;:::o;17778:370::-;;17938:67;18002:2;17997:3;17938:67;:::i;:::-;17931:74;;18038:34;18034:1;18029:3;18025:11;18018:55;18107:3;18102:2;18097:3;18093:12;18086:25;18139:2;18134:3;18130:12;18123:19;;17924:224;;;:::o;18157:391::-;;18317:67;18381:2;18376:3;18317:67;:::i;:::-;18310:74;;18417:34;18413:1;18408:3;18404:11;18397:55;18486:24;18481:2;18476:3;18472:12;18465:46;18539:2;18534:3;18530:12;18523:19;;18303:245;;;:::o;18557:321::-;;18717:67;18781:2;18776:3;18717:67;:::i;:::-;18710:74;;18817:23;18813:1;18808:3;18804:11;18797:44;18869:2;18864:3;18860:12;18853:19;;18703:175;;;:::o;18887:332::-;;19047:67;19111:2;19106:3;19047:67;:::i;:::-;19040:74;;19147:34;19143:1;19138:3;19134:11;19127:55;19210:2;19205:3;19201:12;19194:19;;19033:186;;;:::o;19228:315::-;;19388:67;19452:2;19447:3;19388:67;:::i;:::-;19381:74;;19488:17;19484:1;19479:3;19475:11;19468:38;19534:2;19529:3;19525:12;19518:19;;19374:169;;;:::o;19552:326::-;;19712:67;19776:2;19771:3;19712:67;:::i;:::-;19705:74;;19812:28;19808:1;19803:3;19799:11;19792:49;19869:2;19864:3;19860:12;19853:19;;19698:180;;;:::o;19887:312::-;;20047:67;20111:2;20106:3;20047:67;:::i;:::-;20040:74;;20147:14;20143:1;20138:3;20134:11;20127:35;20190:2;20185:3;20181:12;20174:19;;20033:166;;;:::o;20208:322::-;;20368:67;20432:2;20427:3;20368:67;:::i;:::-;20361:74;;20468:24;20464:1;20459:3;20455:11;20448:45;20521:2;20516:3;20512:12;20505:19;;20354:176;;;:::o;20539:376::-;;20699:67;20763:2;20758:3;20699:67;:::i;:::-;20692:74;;20799:34;20795:1;20790:3;20786:11;20779:55;20868:9;20863:2;20858:3;20854:12;20847:31;20906:2;20901:3;20897:12;20890:19;;20685:230;;;:::o;20924:317::-;;21084:67;21148:2;21143:3;21084:67;:::i;:::-;21077:74;;21184:19;21180:1;21175:3;21171:11;21164:40;21232:2;21227:3;21223:12;21216:19;;21070:171;;;:::o;21250:329::-;;21410:67;21474:2;21469:3;21410:67;:::i;:::-;21403:74;;21510:31;21506:1;21501:3;21497:11;21490:52;21570:2;21565:3;21561:12;21554:19;;21396:183;;;:::o;21588:376::-;;21748:67;21812:2;21807:3;21748:67;:::i;:::-;21741:74;;21848:34;21844:1;21839:3;21835:11;21828:55;21917:9;21912:2;21907:3;21903:12;21896:31;21955:2;21950:3;21946:12;21939:19;;21734:230;;;:::o;21973:391::-;;22133:67;22197:2;22192:3;22133:67;:::i;:::-;22126:74;;22233:34;22229:1;22224:3;22220:11;22213:55;22302:24;22297:2;22292:3;22288:12;22281:46;22355:2;22350:3;22346:12;22339:19;;22119:245;;;:::o;22373:379::-;;22533:67;22597:2;22592:3;22533:67;:::i;:::-;22526:74;;22633:34;22629:1;22624:3;22620:11;22613:55;22702:12;22697:2;22692:3;22688:12;22681:34;22743:2;22738:3;22734:12;22727:19;;22519:233;;;:::o;22761:332::-;;22921:67;22985:2;22980:3;22921:67;:::i;:::-;22914:74;;23021:34;23017:1;23012:3;23008:11;23001:55;23084:2;23079:3;23075:12;23068:19;;22907:186;;;:::o;23102:315::-;;23262:67;23326:2;23321:3;23262:67;:::i;:::-;23255:74;;23362:17;23358:1;23353:3;23349:11;23342:38;23408:2;23403:3;23399:12;23392:19;;23248:169;;;:::o;23426:328::-;;23586:67;23650:2;23645:3;23586:67;:::i;:::-;23579:74;;23686:30;23682:1;23677:3;23673:11;23666:51;23745:2;23740:3;23736:12;23729:19;;23572:182;;;:::o;23863:599::-;24024:6;24019:3;24015:16;24110:4;24103:5;24099:16;24093:23;24122:107;24223:4;24218:3;24214:14;24200:12;24122:107;:::i;:::-;24046:189;24314:4;24307:5;24303:16;24297:23;24326:115;24435:4;24430:3;24426:14;24412:12;24326:115;:::i;:::-;24245:202;23997:465;;;:::o;24536:1078::-;24663:4;24658:3;24654:14;24748:4;24741:5;24737:16;24731:23;24760:57;24811:4;24806:3;24802:14;24788:12;24760:57;:::i;:::-;24683:140;24898:4;24891:5;24887:16;24881:23;24910:63;24967:4;24962:3;24958:14;24944:12;24910:63;:::i;:::-;24833:146;25052:4;25045:5;25041:16;25035:23;25064:63;25121:4;25116:3;25112:14;25098:12;25064:63;:::i;:::-;24989:144;25209:4;25202:5;25198:16;25192:23;25221:63;25278:4;25273:3;25269:14;25255:12;25221:63;:::i;:::-;25143:147;25361:4;25354:5;25350:16;25344:23;25373:63;25430:4;25425:3;25421:14;25407:12;25373:63;:::i;:::-;25300:142;25518:4;25511:5;25507:16;25501:23;25530:63;25587:4;25582:3;25578:14;25564:12;25530:63;:::i;:::-;25452:147;24636:978;;;:::o;25666:773::-;25801:4;25796:3;25792:14;25886:4;25879:5;25875:16;25869:23;25898:57;25949:4;25944:3;25940:14;25926:12;25898:57;:::i;:::-;25821:140;26035:4;26028:5;26024:16;26018:23;26047:63;26104:4;26099:3;26095:14;26081:12;26047:63;:::i;:::-;25971:145;26189:4;26182:5;26178:16;26172:23;26201:63;26258:4;26253:3;26249:14;26235:12;26201:63;:::i;:::-;26126:144;26343:4;26336:5;26332:16;26326:23;26355:63;26412:4;26407:3;26403:14;26389:12;26355:63;:::i;:::-;26280:144;25774:665;;;:::o;26535:1506::-;26694:6;26689:3;26685:16;26793:4;26786:5;26782:16;26776:23;26805:57;26856:4;26851:3;26847:14;26833:12;26805:57;:::i;:::-;26716:152;26956:4;26949:5;26945:16;26939:23;26968:63;27025:4;27020:3;27016:14;27002:12;26968:63;:::i;:::-;26878:159;27116:4;27109:5;27105:16;27099:23;27128:63;27185:4;27180:3;27176:14;27162:12;27128:63;:::i;:::-;27047:150;27286:4;27279:5;27275:16;27269:23;27298:63;27355:4;27350:3;27346:14;27332:12;27298:63;:::i;:::-;27207:160;27457:4;27450:5;27446:16;27440:23;27469:63;27526:4;27521:3;27517:14;27503:12;27469:63;:::i;:::-;27377:161;27631:4;27624:5;27620:16;27614:23;27643:63;27700:4;27695:3;27691:14;27677:12;27643:63;:::i;:::-;27548:164;27791:4;27784:5;27780:16;27774:23;27803:63;27860:4;27855:3;27851:14;27837:12;27803:63;:::i;:::-;27722:150;27945:4;27938:5;27934:16;27928:23;27957:63;28014:4;28009:3;28005:14;27991:12;27957:63;:::i;:::-;27882:144;26667:1374;;;:::o;28137:956::-;28296:4;28291:3;28287:14;28381:4;28374:5;28370:16;28364:23;28393:57;28444:4;28439:3;28435:14;28421:12;28393:57;:::i;:::-;28316:140;28535:4;28528:5;28524:16;28518:23;28547:57;28598:4;28593:3;28589:14;28575:12;28547:57;:::i;:::-;28466:144;28685:4;28678:5;28674:16;28668:23;28697:57;28748:4;28743:3;28739:14;28725:12;28697:57;:::i;:::-;28620:140;28841:4;28834:5;28830:16;28824:23;28853:63;28910:4;28905:3;28901:14;28887:12;28853:63;:::i;:::-;28770:152;28997:4;28990:5;28986:16;28980:23;29009:63;29066:4;29061:3;29057:14;29043:12;29009:63;:::i;:::-;28932:146;28269:824;;;:::o;29177:1839::-;;29332:6;29327:3;29323:16;29419:4;29412:5;29408:16;29402:23;29431:57;29482:4;29477:3;29473:14;29459:12;29431:57;:::i;:::-;29354:140;29571:4;29564:5;29560:16;29554:23;29583:63;29640:4;29635:3;29631:14;29617:12;29583:63;:::i;:::-;29504:148;29727:4;29720:5;29716:16;29710:23;29739:63;29796:4;29791:3;29787:14;29773:12;29739:63;:::i;:::-;29662:146;29882:4;29875:5;29871:16;29865:23;29894:63;29951:4;29946:3;29942:14;29928:12;29894:63;:::i;:::-;29818:145;30051:4;30044:5;30040:16;30034:23;30063:63;30120:4;30115:3;30111:14;30097:12;30063:63;:::i;:::-;29973:159;30213:4;30206:5;30202:16;30196:23;30225:63;30282:4;30277:3;30273:14;30259:12;30225:63;:::i;:::-;30142:152;30374:4;30367:5;30363:16;30357:23;30386:63;30443:4;30438:3;30434:14;30420:12;30386:63;:::i;:::-;30304:151;30536:4;30529:5;30525:16;30519:23;30588:3;30582:4;30578:14;30571:4;30566:3;30562:14;30555:38;30608:103;30706:4;30692:12;30608:103;:::i;:::-;30600:111;;30465:258;30799:6;30792:5;30788:18;30782:25;30855:3;30849:4;30845:14;30836:6;30831:3;30827:16;30820:40;30875:103;30973:4;30959:12;30875:103;:::i;:::-;30867:111;;30733:257;31007:4;31000:11;;29305:1711;;;;;:::o;31023:103::-;31096:24;31114:5;31096:24;:::i;:::-;31091:3;31084:37;31078:48;;:::o;31133:113::-;31216:24;31234:5;31216:24;:::i;:::-;31211:3;31204:37;31198:48;;:::o;31253:152::-;31354:45;31374:24;31392:5;31374:24;:::i;:::-;31354:45;:::i;:::-;31349:3;31342:58;31336:69;;:::o;31412:424::-;;31584:91;31671:3;31662:6;31584:91;:::i;:::-;31697:2;31692:3;31688:12;31681:19;;31711:75;31782:3;31773:6;31711:75;:::i;:::-;31808:2;31803:3;31799:12;31792:19;;31828:3;31821:10;;31572:264;;;;;:::o;31843:392::-;;31999:75;32070:3;32061:6;31999:75;:::i;:::-;32096:2;32091:3;32087:12;32080:19;;32110:75;32181:3;32172:6;32110:75;:::i;:::-;32207:2;32202:3;32198:12;32191:19;;32227:3;32220:10;;31987:248;;;;;:::o;32242:392::-;;32398:75;32469:3;32460:6;32398:75;:::i;:::-;32495:2;32490:3;32486:12;32479:19;;32509:75;32580:3;32571:6;32509:75;:::i;:::-;32606:2;32601:3;32597:12;32590:19;;32626:3;32619:10;;32386:248;;;;;:::o;32641:271::-;;32794:93;32883:3;32874:6;32794:93;:::i;:::-;32787:100;;32904:3;32897:10;;32775:137;;;;:::o;32919:222::-;;33046:2;33035:9;33031:18;33023:26;;33060:71;33128:1;33117:9;33113:17;33104:6;33060:71;:::i;:::-;33017:124;;;;:::o;33148:444::-;;33331:2;33320:9;33316:18;33308:26;;33345:71;33413:1;33402:9;33398:17;33389:6;33345:71;:::i;:::-;33427:72;33495:2;33484:9;33480:18;33471:6;33427:72;:::i;:::-;33510;33578:2;33567:9;33563:18;33554:6;33510:72;:::i;:::-;33302:290;;;;;;:::o;33599:333::-;;33754:2;33743:9;33739:18;33731:26;;33768:71;33836:1;33825:9;33821:17;33812:6;33768:71;:::i;:::-;33850:72;33918:2;33907:9;33903:18;33894:6;33850:72;:::i;:::-;33725:207;;;;;:::o;33939:458::-;;34160:2;34149:9;34145:18;34137:26;;34210:9;34204:4;34200:20;34196:1;34185:9;34181:17;34174:47;34235:152;34382:4;34373:6;34235:152;:::i;:::-;34227:160;;34131:266;;;;:::o;34404:210::-;;34525:2;34514:9;34510:18;34502:26;;34539:65;34601:1;34590:9;34586:17;34577:6;34539:65;:::i;:::-;34496:118;;;;:::o;34621:222::-;;34748:2;34737:9;34733:18;34725:26;;34762:71;34830:1;34819:9;34815:17;34806:6;34762:71;:::i;:::-;34719:124;;;;:::o;34850:333::-;;35005:2;34994:9;34990:18;34982:26;;35019:71;35087:1;35076:9;35072:17;35063:6;35019:71;:::i;:::-;35101:72;35169:2;35158:9;35154:18;35145:6;35101:72;:::i;:::-;34976:207;;;;;:::o;35190:333::-;;35345:2;35334:9;35330:18;35322:26;;35359:71;35427:1;35416:9;35412:17;35403:6;35359:71;:::i;:::-;35441:72;35509:2;35498:9;35494:18;35485:6;35441:72;:::i;:::-;35316:207;;;;;:::o;35530:252::-;;35672:2;35661:9;35657:18;35649:26;;35686:86;35769:1;35758:9;35754:17;35745:6;35686:86;:::i;:::-;35643:139;;;;:::o;35789:310::-;;35936:2;35925:9;35921:18;35913:26;;35986:9;35980:4;35976:20;35972:1;35961:9;35957:17;35950:47;36011:78;36084:4;36075:6;36011:78;:::i;:::-;36003:86;;35907:192;;;;:::o;36106:416::-;;36306:2;36295:9;36291:18;36283:26;;36356:9;36350:4;36346:20;36342:1;36331:9;36327:17;36320:47;36381:131;36507:4;36381:131;:::i;:::-;36373:139;;36277:245;;;:::o;36529:416::-;;36729:2;36718:9;36714:18;36706:26;;36779:9;36773:4;36769:20;36765:1;36754:9;36750:17;36743:47;36804:131;36930:4;36804:131;:::i;:::-;36796:139;;36700:245;;;:::o;36952:416::-;;37152:2;37141:9;37137:18;37129:26;;37202:9;37196:4;37192:20;37188:1;37177:9;37173:17;37166:47;37227:131;37353:4;37227:131;:::i;:::-;37219:139;;37123:245;;;:::o;37375:416::-;;37575:2;37564:9;37560:18;37552:26;;37625:9;37619:4;37615:20;37611:1;37600:9;37596:17;37589:47;37650:131;37776:4;37650:131;:::i;:::-;37642:139;;37546:245;;;:::o;37798:416::-;;37998:2;37987:9;37983:18;37975:26;;38048:9;38042:4;38038:20;38034:1;38023:9;38019:17;38012:47;38073:131;38199:4;38073:131;:::i;:::-;38065:139;;37969:245;;;:::o;38221:416::-;;38421:2;38410:9;38406:18;38398:26;;38471:9;38465:4;38461:20;38457:1;38446:9;38442:17;38435:47;38496:131;38622:4;38496:131;:::i;:::-;38488:139;;38392:245;;;:::o;38644:416::-;;38844:2;38833:9;38829:18;38821:26;;38894:9;38888:4;38884:20;38880:1;38869:9;38865:17;38858:47;38919:131;39045:4;38919:131;:::i;:::-;38911:139;;38815:245;;;:::o;39067:416::-;;39267:2;39256:9;39252:18;39244:26;;39317:9;39311:4;39307:20;39303:1;39292:9;39288:17;39281:47;39342:131;39468:4;39342:131;:::i;:::-;39334:139;;39238:245;;;:::o;39490:416::-;;39690:2;39679:9;39675:18;39667:26;;39740:9;39734:4;39730:20;39726:1;39715:9;39711:17;39704:47;39765:131;39891:4;39765:131;:::i;:::-;39757:139;;39661:245;;;:::o;39913:416::-;;40113:2;40102:9;40098:18;40090:26;;40163:9;40157:4;40153:20;40149:1;40138:9;40134:17;40127:47;40188:131;40314:4;40188:131;:::i;:::-;40180:139;;40084:245;;;:::o;40336:416::-;;40536:2;40525:9;40521:18;40513:26;;40586:9;40580:4;40576:20;40572:1;40561:9;40557:17;40550:47;40611:131;40737:4;40611:131;:::i;:::-;40603:139;;40507:245;;;:::o;40759:416::-;;40959:2;40948:9;40944:18;40936:26;;41009:9;41003:4;40999:20;40995:1;40984:9;40980:17;40973:47;41034:131;41160:4;41034:131;:::i;:::-;41026:139;;40930:245;;;:::o;41182:416::-;;41382:2;41371:9;41367:18;41359:26;;41432:9;41426:4;41422:20;41418:1;41407:9;41403:17;41396:47;41457:131;41583:4;41457:131;:::i;:::-;41449:139;;41353:245;;;:::o;41605:416::-;;41805:2;41794:9;41790:18;41782:26;;41855:9;41849:4;41845:20;41841:1;41830:9;41826:17;41819:47;41880:131;42006:4;41880:131;:::i;:::-;41872:139;;41776:245;;;:::o;42028:416::-;;42228:2;42217:9;42213:18;42205:26;;42278:9;42272:4;42268:20;42264:1;42253:9;42249:17;42242:47;42303:131;42429:4;42303:131;:::i;:::-;42295:139;;42199:245;;;:::o;42451:416::-;;42651:2;42640:9;42636:18;42628:26;;42701:9;42695:4;42691:20;42687:1;42676:9;42672:17;42665:47;42726:131;42852:4;42726:131;:::i;:::-;42718:139;;42622:245;;;:::o;42874:416::-;;43074:2;43063:9;43059:18;43051:26;;43124:9;43118:4;43114:20;43110:1;43099:9;43095:17;43088:47;43149:131;43275:4;43149:131;:::i;:::-;43141:139;;43045:245;;;:::o;43297:416::-;;43497:2;43486:9;43482:18;43474:26;;43547:9;43541:4;43537:20;43533:1;43522:9;43518:17;43511:47;43572:131;43698:4;43572:131;:::i;:::-;43564:139;;43468:245;;;:::o;43720:416::-;;43920:2;43909:9;43905:18;43897:26;;43970:9;43964:4;43960:20;43956:1;43945:9;43941:17;43934:47;43995:131;44121:4;43995:131;:::i;:::-;43987:139;;43891:245;;;:::o;44143:416::-;;44343:2;44332:9;44328:18;44320:26;;44393:9;44387:4;44383:20;44379:1;44368:9;44364:17;44357:47;44418:131;44544:4;44418:131;:::i;:::-;44410:139;;44314:245;;;:::o;44566:416::-;;44766:2;44755:9;44751:18;44743:26;;44816:9;44810:4;44806:20;44802:1;44791:9;44787:17;44780:47;44841:131;44967:4;44841:131;:::i;:::-;44833:139;;44737:245;;;:::o;44989:416::-;;45189:2;45178:9;45174:18;45166:26;;45239:9;45233:4;45229:20;45225:1;45214:9;45210:17;45203:47;45264:131;45390:4;45264:131;:::i;:::-;45256:139;;45160:245;;;:::o;45412:416::-;;45612:2;45601:9;45597:18;45589:26;;45662:9;45656:4;45652:20;45648:1;45637:9;45633:17;45626:47;45687:131;45813:4;45687:131;:::i;:::-;45679:139;;45583:245;;;:::o;45835:416::-;;46035:2;46024:9;46020:18;46012:26;;46085:9;46079:4;46075:20;46071:1;46060:9;46056:17;46049:47;46110:131;46236:4;46110:131;:::i;:::-;46102:139;;46006:245;;;:::o;46258:416::-;;46458:2;46447:9;46443:18;46435:26;;46508:9;46502:4;46498:20;46494:1;46483:9;46479:17;46472:47;46533:131;46659:4;46533:131;:::i;:::-;46525:139;;46429:245;;;:::o;46681:416::-;;46881:2;46870:9;46866:18;46858:26;;46931:9;46925:4;46921:20;46917:1;46906:9;46902:17;46895:47;46956:131;47082:4;46956:131;:::i;:::-;46948:139;;46852:245;;;:::o;47104:416::-;;47304:2;47293:9;47289:18;47281:26;;47354:9;47348:4;47344:20;47340:1;47329:9;47325:17;47318:47;47379:131;47505:4;47379:131;:::i;:::-;47371:139;;47275:245;;;:::o;47527:416::-;;47727:2;47716:9;47712:18;47704:26;;47777:9;47771:4;47767:20;47763:1;47752:9;47748:17;47741:47;47802:131;47928:4;47802:131;:::i;:::-;47794:139;;47698:245;;;:::o;47950:416::-;;48150:2;48139:9;48135:18;48127:26;;48200:9;48194:4;48190:20;48186:1;48175:9;48171:17;48164:47;48225:131;48351:4;48225:131;:::i;:::-;48217:139;;48121:245;;;:::o;48373:416::-;;48573:2;48562:9;48558:18;48550:26;;48623:9;48617:4;48613:20;48609:1;48598:9;48594:17;48587:47;48648:131;48774:4;48648:131;:::i;:::-;48640:139;;48544:245;;;:::o;48796:416::-;;48996:2;48985:9;48981:18;48973:26;;49046:9;49040:4;49036:20;49032:1;49021:9;49017:17;49010:47;49071:131;49197:4;49071:131;:::i;:::-;49063:139;;48967:245;;;:::o;49219:416::-;;49419:2;49408:9;49404:18;49396:26;;49469:9;49463:4;49459:20;49455:1;49444:9;49440:17;49433:47;49494:131;49620:4;49494:131;:::i;:::-;49486:139;;49390:245;;;:::o;49642:416::-;;49842:2;49831:9;49827:18;49819:26;;49892:9;49886:4;49882:20;49878:1;49867:9;49863:17;49856:47;49917:131;50043:4;49917:131;:::i;:::-;49909:139;;49813:245;;;:::o;50065:416::-;;50265:2;50254:9;50250:18;50242:26;;50315:9;50309:4;50305:20;50301:1;50290:9;50286:17;50279:47;50340:131;50466:4;50340:131;:::i;:::-;50332:139;;50236:245;;;:::o;50488:416::-;;50688:2;50677:9;50673:18;50665:26;;50738:9;50732:4;50728:20;50724:1;50713:9;50709:17;50702:47;50763:131;50889:4;50763:131;:::i;:::-;50755:139;;50659:245;;;:::o;50911:416::-;;51111:2;51100:9;51096:18;51088:26;;51161:9;51155:4;51151:20;51147:1;51136:9;51132:17;51125:47;51186:131;51312:4;51186:131;:::i;:::-;51178:139;;51082:245;;;:::o;51334:416::-;;51534:2;51523:9;51519:18;51511:26;;51584:9;51578:4;51574:20;51570:1;51559:9;51555:17;51548:47;51609:131;51735:4;51609:131;:::i;:::-;51601:139;;51505:245;;;:::o;51757:416::-;;51957:2;51946:9;51942:18;51934:26;;52007:9;52001:4;51997:20;51993:1;51982:9;51978:17;51971:47;52032:131;52158:4;52032:131;:::i;:::-;52024:139;;51928:245;;;:::o;52180:416::-;;52380:2;52369:9;52365:18;52357:26;;52430:9;52424:4;52420:20;52416:1;52405:9;52401:17;52394:47;52455:131;52581:4;52455:131;:::i;:::-;52447:139;;52351:245;;;:::o;52603:416::-;;52803:2;52792:9;52788:18;52780:26;;52853:9;52847:4;52843:20;52839:1;52828:9;52824:17;52817:47;52878:131;53004:4;52878:131;:::i;:::-;52870:139;;52774:245;;;:::o;53026:416::-;;53226:2;53215:9;53211:18;53203:26;;53276:9;53270:4;53266:20;53262:1;53251:9;53247:17;53240:47;53301:131;53427:4;53301:131;:::i;:::-;53293:139;;53197:245;;;:::o;53449:355::-;;53642:3;53631:9;53627:19;53619:27;;53657:137;53791:1;53780:9;53776:17;53767:6;53657:137;:::i;:::-;53613:191;;;;:::o;53811:355::-;;54004:3;53993:9;53989:19;53981:27;;54019:137;54153:1;54142:9;54138:17;54129:6;54019:137;:::i;:::-;53975:191;;;;:::o;54173:378::-;;54354:2;54343:9;54339:18;54331:26;;54404:9;54398:4;54394:20;54390:1;54379:9;54375:17;54368:47;54429:112;54536:4;54527:6;54429:112;:::i;:::-;54421:120;;54325:226;;;;:::o;54558:222::-;;54685:2;54674:9;54670:18;54662:26;;54699:71;54767:1;54756:9;54752:17;54743:6;54699:71;:::i;:::-;54656:124;;;;:::o;54787:972::-;;55154:3;55143:9;55139:19;55131:27;;55169:71;55237:1;55226:9;55222:17;55213:6;55169:71;:::i;:::-;55251:72;55319:2;55308:9;55304:18;55295:6;55251:72;:::i;:::-;55334;55402:2;55391:9;55387:18;55378:6;55334:72;:::i;:::-;55417;55485:2;55474:9;55470:18;55461:6;55417:72;:::i;:::-;55538:9;55532:4;55528:20;55522:3;55511:9;55507:19;55500:49;55563:186;55744:4;55735:6;55563:186;:::i;:::-;55555:194;;55125:634;;;;;;;;:::o;55766:256::-;;55828:2;55822:9;55812:19;;55866:4;55858:6;55854:17;55965:6;55953:10;55950:22;55929:18;55917:10;55914:34;55911:62;55908:2;;;55986:1;55983;55976:12;55908:2;56006:10;56002:2;55995:22;55806:216;;;;:::o;56029:304::-;;56188:18;56180:6;56177:30;56174:2;;;56220:1;56217;56210:12;56174:2;56255:4;56247:6;56243:17;56235:25;;56318:4;56312;56308:15;56300:23;;56111:222;;;:::o;56340:151::-;;56426:3;56418:11;;56464:4;56459:3;56455:14;56447:22;;56412:79;;;:::o;56498:190::-;;56623:3;56615:11;;56661:4;56656:3;56652:14;56644:22;;56609:79;;;:::o;56695:173::-;;56803:3;56795:11;;56841:4;56836:3;56832:14;56824:22;;56789:79;;;:::o;56875:137::-;;56984:5;56978:12;56968:22;;56949:63;;;:::o;57019:176::-;;57167:5;57161:12;57151:22;;57132:63;;;:::o;57202:159::-;;57333:5;57327:12;57317:22;;57298:63;;;:::o;57368:121::-;;57461:5;57455:12;57445:22;;57426:63;;;:::o;57496:122::-;;57590:5;57584:12;57574:22;;57555:63;;;:::o;57625:108::-;;57723:4;57718:3;57714:14;57706:22;;57700:33;;;:::o;57740:147::-;;57877:4;57872:3;57868:14;57860:22;;57854:33;;;:::o;57894:130::-;;58014:4;58009:3;58005:14;57997:22;;57991:33;;;:::o;58032:168::-;;58152:6;58147:3;58140:19;58189:4;58184:3;58180:14;58165:29;;58133:67;;;;:::o;58209:217::-;;58378:6;58373:3;58366:19;58415:4;58410:3;58406:14;58391:29;;58359:67;;;;:::o;58435:200::-;;58587:6;58582:3;58575:19;58624:4;58619:3;58615:14;58600:29;;58568:67;;;;:::o;58644:144::-;;58779:3;58764:18;;58757:31;;;;:::o;58797:163::-;;58912:6;58907:3;58900:19;58949:4;58944:3;58940:14;58925:29;;58893:67;;;;:::o;58968:91::-;;59030:24;59048:5;59030:24;:::i;:::-;59019:35;;59013:46;;;:::o;59066:99::-;;59136:24;59154:5;59136:24;:::i;:::-;59125:35;;59119:46;;;:::o;59172:85::-;;59245:5;59238:13;59231:21;59220:32;;59214:43;;;:::o;59264:72::-;;59326:5;59315:16;;59309:27;;;:::o;59343:121::-;;59416:42;59409:5;59405:54;59394:65;;59388:76;;;:::o;59471:72::-;;59533:5;59522:16;;59516:27;;;:::o;59550:151::-;;59644:52;59690:5;59644:52;:::i;:::-;59631:65;;59625:76;;;:::o;59708:123::-;;59802:24;59820:5;59802:24;:::i;:::-;59789:37;;59783:48;;;:::o;59839:268::-;59904:1;59911:101;59925:6;59922:1;59919:13;59911:101;;;60001:1;59996:3;59992:11;59986:18;59982:1;59977:3;59973:11;59966:39;59947:2;59944:1;59940:10;59935:15;;59911:101;;;60027:6;60024:1;60021:13;60018:2;;;60092:1;60083:6;60078:3;60074:16;60067:27;60018:2;59888:219;;;;:::o;60115:103::-;;60187:26;60207:5;60187:26;:::i;:::-;60176:37;;60170:48;;;:::o;60225:74::-;;60289:5;60278:16;;60272:27;;;:::o;60306:89::-;;60370:20;60384:5;60370:20;:::i;:::-;60359:31;;60353:42;;;:::o;60402:74::-;;60466:5;60455:16;;60449:27;;;:::o;60483:97::-;;60571:2;60567:7;60562:2;60555:5;60551:14;60547:28;60537:38;;60531:49;;;:::o;60588:94::-;;60666:5;60662:2;60658:14;60636:36;;60630:52;;;:::o;60690:117::-;60759:24;60777:5;60759:24;:::i;:::-;60752:5;60749:35;60739:2;;60798:1;60795;60788:12;60739:2;60733:74;:::o;60814:111::-;60880:21;60895:5;60880:21;:::i;:::-;60873:5;60870:32;60860:2;;60916:1;60913;60906:12;60860:2;60854:71;:::o;60932:117::-;61001:24;61019:5;61001:24;:::i;:::-;60994:5;60991:35;60981:2;;61040:1;61037;61030:12;60981:2;60975:74;:::o;61056:117::-;61125:24;61143:5;61125:24;:::i;:::-;61118:5;61115:35;61105:2;;61164:1;61161;61154:12;61105:2;61099:74;:::o

Swarm Source

ipfs://0a5687aad47ae3bb2b219ac3a1b07703cc4ee097c50d6837f1195f48a11b57f7
Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.