Contract 0xe5d7df5a6a057b6a909d564dddabdc848e51a038 2

// 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");
        _;
    }
}

// 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);
    }
}

// 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;
    }
}

// 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);
            }
        }
    }
}

// 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");
        }
    }
}

// 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);
}

// 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;
    }
}

// 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);
    }
}

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"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"}]

60806040526040518060a00160405280600260ff168152602001600460ff168152602001600860ff168152602001601060ff168152602001601060ff1681525060059060056200005192919062000264565b503480156200005f57600080fd5b506040516200633e3803806200633e833981810160405281019062000085919062000312565b80600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415620000f9576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401620000f090620003c0565b60405180910390fd5b6200010a81620001dd60201b60201c565b5083600360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555082600460006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550600a6001816001815401808255809150500390600052602060002090505081600a600081548110620001bb57fe5b9060005260206000209060180201600001600201819055505050505062000493565b80600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508073ffffffffffffffffffffffffffffffffffffffff167fa2ea9883a321a3e97b8266c2b078bfeec6d50c711ed71f874a90d500ae2eaf3660405160405180910390a250565b82600581019282156200029b579160200282015b828111156200029a578251829060ff1690559160200191906001019062000278565b5b509050620002aa9190620002ae565b5090565b5b80821115620002c9576000816000905550600101620002af565b5090565b600081519050620002de8162000445565b92915050565b600081519050620002f5816200045f565b92915050565b6000815190506200030c8162000479565b92915050565b600080600080608085870312156200032957600080fd5b60006200033987828801620002e4565b94505060206200034c87828801620002e4565b93505060406200035f87828801620002fb565b92505060606200037287828801620002cd565b91505092959194509250565b60006200038d601c83620003e2565b91507f4f776e65722063616e6e6f74206265207a65726f2061646472657373000000006000830152602082019050919050565b60006020820190508181036000830152620003db816200037e565b9050919050565b600082825260208201905092915050565b600062000400826200041b565b9050919050565b60006200041482620003f3565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b6200045081620003f3565b81146200045c57600080fd5b50565b6200046a8162000407565b81146200047657600080fd5b50565b62000484816200043b565b81146200049057600080fd5b50565b615e9b80620004a36000396000f3fe608060405234801561001057600080fd5b506004361061018e5760003560e01c806379ba5097116100de5780638ec9925e11610097578063cf17083911610071578063cf170839146104ed578063dce76e4d1461051d578063dd1264e614610551578063dd1e848e146105815761018e565b80638ec9925e146104815780639342c8f41461049f5780639f5cfe03146104cf5761018e565b806379ba5097146103bb5780637dee21e8146103d9578063805581e6146103f7578063817b1cd21461042757806387e7ae5c146104455780638da5cb5b146104635761018e565b806325d5971f1161014b5780633fabe0c0116101255780633fabe0c01461031f5780634b976c3b1461034f57806353a47bb71461037f57806372f702f31461039d5761018e565b806325d5971f146102a157806334d5f37b146102d15780633bfbec14146103015761018e565b806308be8700146101935780630de819b3146101c3578063112cee44146101f3578063126fe80d146102115780631627540c146102415780631e60ad3614610271575b600080fd5b6101ad60048036038101906101a891906141dc565b6105b1565b6040516101ba9190615513565b60405180910390f35b6101dd60048036038101906101d891906140e9565b610750565b6040516101ea9190615b14565b60405180910390f35b6101fb61081f565b6040516102089190615b51565b60405180910390f35b61022b600480360381019061022691906140c0565b61082a565b6040516102389190615af8565b60405180910390f35b61025b6004803603810190610256919061406e565b6108b2565b6040516102689190615513565b60405180910390f35b61028b600480360381019061028691906140c0565b610956565b60405161029891906154f1565b60405180910390f35b6102bb60048036038101906102b691906140c0565b610a5a565b6040516102c89190615513565b60405180910390f35b6102eb60048036038101906102e691906140c0565b610c32565b6040516102f89190615b2f565b60405180910390f35b610309610dcc565b6040516103169190615b51565b60405180910390f35b610339600480360381019061033491906141a0565b610dd7565b6040516103469190615513565b60405180910390f35b610369600480360381019061036491906141dc565b6110b0565b6040516103769190615513565b60405180910390f35b6103876114c1565b6040516103949190615476565b60405180910390f35b6103a56114e5565b6040516103b2919061559b565b60405180910390f35b6103c361150f565b6040516103d09190615513565b60405180910390f35b6103e1611611565b6040516103ee9190615b51565b60405180910390f35b610411600480360381019061040c91906141a0565b61161c565b60405161041e9190615513565b60405180910390f35b61042f6117ee565b60405161043c9190615b51565b60405180910390f35b61044d6117f8565b60405161045a9190615513565b60405180910390f35b61046b61198a565b6040516104789190615476565b60405180910390f35b6104896119b0565b604051610496919061559b565b60405180910390f35b6104b960048036038101906104b491906140c0565b6119da565b6040516104c69190615513565b60405180910390f35b6104d7611c56565b6040516104e49190615b51565b60405180910390f35b610507600480360381019061050291906140c0565b611c63565b6040516105149190615513565b60405180910390f35b610537600480360381019061053291906140c0565b611e5c565b604051610548959493929190615b6c565b60405180910390f35b61056b600480360381019061056691906141dc565b61202a565b6040516105789190615513565b60405180910390f35b61059b60048036038101906105969190614125565b6122ef565b6040516105a89190615513565b60405180910390f35b600081600081116105f7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016105ee90615838565b60405180910390fd5b6105ff6124b2565b600061060a8561253f565b90506106146125aa565b81600001600201541161065c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161065390615898565b60405180910390fd5b6106768482600001600601546125b290919063ffffffff16565b816000016006018190555061069b8482600001600401546125b290919063ffffffff16565b81600001600401819055503373ffffffffffffffffffffffffffffffffffffffff16857f4130fbc98a3f18ae1e44c52a9645a7f92ba468ce7a05d81c0a89dc026c1b932c866040516106ed9190615b51565b60405180910390a3610744333086600460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16612607909392919063ffffffff16565b60019250505092915050565b610758613e29565b60006107638461253f565b90508060170160008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206040518060a00160405290816000820160009054906101000a900460ff161515151581526020016000820160019054906101000a900460ff161515151581526020016000820160029054906101000a900460ff161515151581526020016001820154815260200160028201548152505091505092915050565b600062093a80905090565b610832613e5e565b61083b8261253f565b600901604051806101000160405290816000820160009054906101000a900460ff161515151581526020016001820154815260200160028201548152602001600382015481526020016004820154815260200160058201548152602001600682015481526020016007820154815250509050919050565b6000600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610944576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161093b90615938565b60405180910390fd5b61094d82612690565b60019050919050565b60606109618261253f565b601601805480602002602001604051908101604052809291908181526020016000905b82821015610a4f57838290600052602060002090600602016040518060c00160405290816000820160009054906101000a900460ff16151515158152602001600182015481526020016002820154815260200160038201548152602001600482015481526020016005820160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152505081526020019060010190610984565b505050509050919050565b6000600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610aec576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610ae390615938565b60405180910390fd5b8160008111610b30576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610b2790615838565b60405180910390fd5b610b7c836040518060400160405280601c81526020017f5374616b696e6720706f6f6c20697320657874696e67756973686564000000008152506002546127169092919063ffffffff16565b6002819055507fa78b9f12a7da0df7ced737c5f83d0c05723bb5f43aab37e233b862710414847283604051610bb19190615b51565b60405180910390a1610c28600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1684600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166127719092919063ffffffff16565b6001915050919050565b610c3a613eab565b610c438261253f565b600001604051806101200160405290816000820160009054906101000a900460ff1615151515815260200160018201548152602001600282015481526020016003820154815260200160048201548152602001600582015481526020016006820154815260200160078201805480602002602001604051908101604052809291908181526020018280548015610d2e57602002820191906000526020600020905b8160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019060010190808311610ce4575b5050505050815260200160088201805480602002602001604051908101604052809291908181526020018280548015610dbc57602002820191906000526020600020905b8160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019060010190808311610d72575b5050505050815250509050919050565b60006207e900905090565b6000600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610e69576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610e6090615938565b60405180910390fd5b6000610e748461253f565b90506000801b816009016007015414610ec2576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610eb990615918565b60405180910390fd5b8060090160000160009054906101000a900460ff16610f16576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f0d906156f8565b60405180910390fd5b60008160090160050154905080610f2b6127f7565b11610f6b576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f6290615678565b60405180910390fd5b6000610f76826127ff565b90506000801b811415610fbe576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610fb5906158f8565b60405180910390fd5b82600901600601543386604051602001610fd99291906153db565b604051602081830303815290604052805190602001201461102f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161102690615998565b60405180910390fd5b60008186604051602001611044929190615407565b604051602081830303815290604052805190602001209050808460090160070181905550867f107e5672d914f9cb403cf5ba0b6cadca8ea3b77331f2a24210fbe3ef540ca558878360405161109a929190615549565b60405180910390a2600194505050505092915050565b600081600081116110f6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016110ed90615838565b60405180910390fd5b6110fe6124b2565b6000339050600061110e8661253f565b90506111186125aa565b816000016002015411611160576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161115790615898565b60405180910390fd5b600061117c8683600901600101546125b290919063ffffffff16565b90506000826016019050600081805490509050600084601101905060006111b28260010154848461280a9092919063ffffffff16565b9050836040518060c001604052806001151581526020018c8152602001886009016001015481526020018381526020018781526020018973ffffffffffffffffffffffffffffffffffffffff16815250908060018154018082558091505060019003906000526020600020906006020160009091909190915060008201518160000160006101000a81548160ff0219169083151502179055506020820151816001015560408201518160020155606082015181600301556080820151816004015560a08201518160050160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550505084866009016001018190555084866000016005018190555060008660170160008973ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002090506113308b82600101546125b290919063ffffffff16565b81600101819055508060000160009054906101000a900460ff166113d45760018160000160006101000a81548160ff02191690831515021790555086600001600701889080600181540180825580915050600190039060005260206000200160009091909190916101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055505b60006113f1670de0b6b3a76400008d6129aa90919063ffffffff16565b9050611408816002546125b290919063ffffffff16565b600281905550848973ffffffffffffffffffffffffffffffffffffffff168e7fef79519c5c873fe4437b5d7591c2ac60896fa489525254970cd9388f246d2fca8f6040516114569190615b51565b60405180910390a46114ad893083600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16612607909392919063ffffffff16565b60019a505050505050505050505092915050565b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6000600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16146115a0576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161159790615978565b60405180910390fd5b6115c960008054906101000a900473ffffffffffffffffffffffffffffffffffffffff16612a1a565b60008060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506001905090565b600062015180905090565b6000600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16146116ae576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016116a590615938565b60405180910390fd5b60006116b98461253f565b90508060090160000160009054906101000a900460ff1615611710576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161170790615ad8565b60405180910390fd5b6117186125aa565b81600001600201541115611761576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161175890615ab8565b60405180910390fd5b60018160090160000160006101000a81548160ff021916908315150217905550828160090160060181905550600060016117996127f7565b019050808260090160050181905550847f02a2498943489e42740628e18ce0c039931c9820b2ee029fa881679440e9738d85836040516117da929190615572565b60405180910390a260019250505092915050565b6000600254905090565b6000806118036125aa565b90506000600a805490509050600a600181600181540180825580915050039060005260206000209050506000600a828154811061183c57fe5b906000526020600020906018020190506000600a611864600185612aa190919063ffffffff16565b8154811061186e57fe5b9060005260206000209060180201905060008061188961081f565b9050858360000160020154106118ba576118b38184600001600201546125b290919063ffffffff16565b915061192d565b60006118e8826118da86600001600201548a612aa190919063ffffffff16565b612aeb90919063ffffffff16565b9050611929611913836119056001856125b290919063ffffffff16565b6129aa90919063ffffffff16565b85600001600201546125b290919063ffffffff16565b9250505b818460000160020181905550847f9dabc2c637f100895272835b1380dc71381557c8025b8c7af70b855e64bd031a836040516119699190615b51565b60405180910390a28484600001600301819055506001965050505050505090565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6000600460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b60008033905060006119eb8461253f565b905060008160170160008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002090508060000160029054906101000a900460ff16611a83576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611a7a90615698565b60405180910390fd5b8060000160019054906101000a900460ff1615611ad5576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611acc90615878565b60405180910390fd5b60008160020154905060008111611b21576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611b18906156b8565b60405180910390fd5b8083600001600401541015611b6b576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611b6290615638565b60405180910390fd5b60018260000160016101000a81548160ff021916908315150217905550611ba2818460000160040154612aa190919063ffffffff16565b83600001600401819055508373ffffffffffffffffffffffffffffffffffffffff16867fb886382d42263e3c08a157dd29a33c435741f36625dbc3acb6fb8c19bbf7824783604051611bf49190615b51565b60405180910390a3611c498482600460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166127719092919063ffffffff16565b6001945050505050919050565b6000600a80549050905090565b600080611c6f8361253f565b90506000611c7b6127f7565b90506000801b826009016007015414611cc9576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611cc090615798565b60405180910390fd5b6000826000016002015490508260090160000160009054906101000a900460ff1615611d6857600083600901600501548311905060008060001b611d1386600901600501546127ff565b14159050818015611d22575080155b611d61576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611d5890615a58565b60405180910390fd5b5050611dcb565b611d706125aa565b611d8a611d7b611611565b836125b290919063ffffffff16565b10611dca576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611dc1906155d8565b60405180910390fd5b5b60018360090160000160006101000a81548160ff0219169083151502179055506000611e09611e04600185612aa190919063ffffffff16565b6127ff565b9050808460090160070181905550857f36882092d483bd52b047770e5cfcdf5e7e4697749bf2abf6f88eea7d569b5c4e82604051611e47919061552e565b60405180910390a26001945050505050919050565b60008060008060606000611e6f8761253f565b90506000816011019050806000015496508060010154955080600301549450806004015493508367ffffffffffffffff81118015611eac57600080fd5b50604051908082528060200260200182016040528015611ee657816020015b611ed3613ef9565b815260200190600190039081611ecb5790505b50925060008160000154905060005b8581101561201d57611f05613f1f565b611f188385612b3590919063ffffffff16565b9050604051806040016040528086601601836020015181548110611f3857fe5b90600052602060002090600602016040518060c00160405290816000820160009054906101000a900460ff16151515158152602001600182015481526020016002820154815260200160038201548152602001600482015481526020016005820160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681525050815260200182815250868381518110611fff57fe5b60200260200101819052508060600151925050600181019050611ef5565b5050505091939590929450565b60006120346124b2565b600061203e6125aa565b9050600061204b8561253f565b600001905060008160070180549050111561211c578060000160009054906101000a900460ff166120b1576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016120a890615818565b60405180910390fd5b60006120d16120be610dcc565b83600101546125b290919063ffffffff16565b905080831015612116576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161210d90615a98565b60405180910390fd5b50612164565b8060020154821015612163576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161215a90615ab8565b60405180910390fd5b5b600081600401549050600081116121b0576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016121a790615658565b60405180910390fd5b60006121bb8661253f565b600001905080600201548410612206576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016121fd906159b8565b60405180910390fd5b61222261221d600188612aa190919063ffffffff16565b61253f565b6000016002015484101561226b576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612262906158b8565b60405180910390fd5b6000836004018190555061228c8282600601546125b290919063ffffffff16565b81600601819055506122ab8282600401546125b290919063ffffffff16565b816004018190555085877fdf3f79258e7e555306e25bc8edefa1f545f767bc7817e5bfd89ce5380c9c832e60405160405180910390a3600194505050505092915050565b6000808211612333576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161232a90615618565b60405180910390fd5b600061233e8661253f565b90506000801b8160090160070154141561238d576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612384906159f8565b60405180910390fd5b8060000160000160009054906101000a900460ff16156123e2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016123d990615758565b60405180910390fd5b806009016003015484111561242c576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612423906155f8565b60405180910390fd5b6000816009016002015414156124995780600901600301546124588587516125b290919063ffffffff16565b11612498576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161248f90615778565b60405180910390fd5b5b6124a581868686612bf5565b6001915050949350505050565b60006124cd6001600a80549050612aa190919063ffffffff16565b90506124d76125aa565b600a82815481106124e457fe5b9060005260206000209060180201600001600201541115612505575061253d565b807faa97d4a7b3afec5f55c25ca8593dde6929d4455fad650a16fa4334004293a61860405160405180910390a261253a6117f8565b50505b565b6000600a805490508210612588576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161257f90615958565b60405180910390fd5b600a828154811061259557fe5b90600052602060002090601802019050919050565b600042905090565b6000808284019050838110156125fd576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016125f490615718565b60405180910390fd5b8091505092915050565b61268a846323b872dd60e01b85858560405160240161262893929190615491565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050612f17565b50505050565b806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508073ffffffffffffffffffffffffffffffffffffffff167f906a1c6bd7e3091ea86693dd029a831c19049ce77f1dce2ce0bab1cacbabce2260405160405180910390a250565b600083831115829061275e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161275591906155b6565b60405180910390fd5b5060008385039050809150509392505050565b6127f28363a9059cbb60e01b84846040516024016127909291906154c8565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050612f17565b505050565b600043905090565b600081409050919050565b60008084600201600085815260200190815260200160002090508060000160009054906101000a900460ff16806128415750600084145b612880576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612877906159d8565b60405180910390fd5b60018560030160008282540192505081905550600085600201600087600301548152602001908152602001600020905060018160000160006101000a81548160ff021916908315150217905550838160010181905550848160020181905550600085146128f15781600301546128f7565b85600001545b8160030181905550856003015482600301819055508560030154866002016000836002015481526020019081526020016000206003018190555085600301548660020160008360030154815260200190815260200160002060020181905550600085141561296d57856003015486600001819055505b856001015485141561298757856003015486600101819055505b600186600401600082825401925050819055508560030154925050509392505050565b6000808314156129bd5760009050612a14565b60008284029050828482816129ce57fe5b0414612a0f576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612a06906158d8565b60405180910390fd5b809150505b92915050565b80600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508073ffffffffffffffffffffffffffffffffffffffff167fa2ea9883a321a3e97b8266c2b078bfeec6d50c711ed71f874a90d500ae2eaf3660405160405180910390a250565b6000612ae383836040518060400160405280601e81526020017f536166654d6174683a207375627472616374696f6e206f766572666c6f770000815250612716565b905092915050565b6000612b2d83836040518060400160405280601a81526020017f536166654d6174683a206469766973696f6e206279207a65726f000000000000815250612fde565b905092915050565b612b3d613f1f565b600083600201600084815260200190815260200160002090508060000160009054906101000a900460ff16612ba7576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612b9e906156d8565b60405180910390fd5b806040518060800160405290816000820160009054906101000a900460ff16151515158152602001600182015481526020016002820154815260200160038201548152505091505092915050565b600084600901600401549050612c156001826125b290919063ffffffff16565b8560090160040181905550600085600901600201541115612c5857612c398561303f565b6001821115612c5257612c5185858560018603612bf5565b5b50612f11565b6000856009016007015482604051602001612c74929190615433565b6040516020818303038152906040528051906020012060001c905060008660090160030154905080612cb08688516125b290919063ffffffff16565b11612cbd57505050612f11565b612cd787600901600101548361363b90919063ffffffff16565b9150600086612cef8784612aa190919063ffffffff16565b81518110612cf957fe5b6020026020010151905087601601805490508110612d4c576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612d43906157b8565b60405180910390fd5b6000886016018281548110612d5d57fe5b90600052602060002090600602019050612d816001846125b290919063ffffffff16565b89600901600301819055508060000160009054906101000a900460ff16612ddd576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612dd4906157d8565b60405180910390fd5b83816002015411158015612df45750838160040154115b612e33576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612e2a90615738565b60405180910390fd5b60008160050160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905060008a60170160008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002090508060000160029054906101000a900460ff16612edf576000612ec48c8385613685565b90508015612ed9575050505050505050612f11565b50612ef0565b82600301548b600901600201819055505b6001881115612f0957612f088b8b8b60018c03612bf5565b5b505050505050505b50505050565b6060612f79826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff1661384e9092919063ffffffff16565b9050600081511115612fd95780806020019051810190612f999190614097565b612fd8576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612fcf90615a78565b60405180910390fd5b5b505050565b60008083118290613025576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161301c91906155b6565b60405180910390fd5b50600083858161303157fe5b049050809150509392505050565b6000816011019050600061306082600101548361386690919063ffffffff16565b9050600083601601828154811061307357fe5b9060005260206000209060060201905061308b613f1f565b6130a5856009016002015485612b3590919063ffffffff16565b90506000856016018260200151815481106130bc57fe5b90600052602060002090600602019050856009016002015485600101541415613156576130fd83600101548760090160010154612aa190919063ffffffff16565b86600901600101819055506131228660090160020154866138df90919063ffffffff16565b6000866009016002018190555060008160000160006101000a81548160ff0219169083151502179055505050505050613638565b60008660170160008560050160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002090508060000160029054906101000a900460ff161561323e576131f484600101548860090160010154612aa190919063ffffffff16565b87600901600101819055506132168660010154876138df90919063ffffffff16565b60008460000160006101000a81548160ff021916908315150217905550505050505050613638565b6000613252836001015486600101546139fc565b905061326e818960090160010154612aa190919063ffffffff16565b8860090160010181905550600084604001511115613356576000886016016132a386604001518a61386690919063ffffffff16565b815481106132ad57fe5b906000526020600020906006020190508560050160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168160050160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614156133545761334789828689868d613a15565b5050505050505050613638565b505b6000846060015111801561337257508660010154846060015114155b156134475760008860160161339486606001518a61386690919063ffffffff16565b8154811061339e57fe5b906000526020600020906006020190508560050160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168160050160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614156134455761343889828689868d613ad1565b5050505050505050613638565b505b6000886016018054905090506000846002015490506134738386600201546125b290919063ffffffff16565b8560020181905550613492838660010154612aa190919063ffffffff16565b85600101819055506134b1838860010154612aa190919063ffffffff16565b87600101819055506134d0838860040154612aa190919063ffffffff16565b876004018190555060006134f38760400151848c61280a9092919063ffffffff16565b90508a6016016040518060c00160405280600115158152602001868152602001848152602001838152602001886002015481526020018a60050160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815250908060018154018082558091505060019003906000526020600020906006020160009091909190915060008201518160000160006101000a81548160ff0219169083151502179055506020820151816001015560408201518160020155606082015181600301556080820151816004015560a08201518160050160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550505061362d8b878a8d613b8d565b505050505050505050505b50565b600061367d83836040518060400160405280601881526020017f536166654d6174683a206d6f64756c6f206279207a65726f0000000000000000815250613c27565b905092915050565b6000806136ba60058660000160080180549050600581106136a257fe5b01548660000160060154612aeb90919063ffffffff16565b905080846002018190555060018460000160026101000a81548160ff02191690831515021790555084600001600801839080600181540180825580915050600190039060005260206000200160009091909190916101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506000856000016008018054905090508373ffffffffffffffffffffffffffffffffffffffff1686600001600301547f51717f575c62af12c537bf652bd8c4fe4eb97454d8a29042b45342ba4002db4f846040516137a79190615b51565b60405180910390a36005811015806137c9575085600001600701805490508110155b156138405785600001600301547fe9f7d7fd0b133404f0ccff737d6f3594748e04bc5507adfaed35835ef989371160405160405180910390a260018660000160000160006101000a81548160ff02191690831515021790555061382a6125aa565b8660000160010181905550600192505050613847565b6000925050505b9392505050565b606061385d8484600085613c83565b90509392505050565b60008083600201600084815260200190815260200160002090508060000160009054906101000a900460ff166138d1576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016138c890615858565b60405180910390fd5b806001015491505092915050565b600082600201600083815260200190815260200160002090508060000160009054906101000a900460ff16613949576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161394090615a38565b60405180910390fd5b60008160000160006101000a81548160ff021916908315150217905550806003015483600201600083600201548152602001908152602001600020600301819055508060020154836002016000836003015481526020019081526020016000206002018190555081836000015414156139ca57806003015483600001819055505b81836001015414156139e457806002015483600101819055505b60018360040160008282540392505081905550505050565b6000818310613a0b5781613a0d565b825b905092915050565b613a2c8286600101546125b290919063ffffffff16565b8560010181905550613a4b8286600401546125b290919063ffffffff16565b856004018190555084600401548460020181905550613a77828560010154612aa190919063ffffffff16565b8460010181905550613a96828460040154612aa190919063ffffffff16565b8360040181905550613ab5828460010154612aa190919063ffffffff16565b8360010181905550613ac986858584613b8d565b505050505050565b613ae88286600101546125b290919063ffffffff16565b8560010181905550613b07828660020154612aa190919063ffffffff16565b856002018190555084600201548460040181905550613b33828560010154612aa190919063ffffffff16565b8460010181905550613b52828460040154612aa190919063ffffffff16565b8360040181905550613b71828460010154612aa190919063ffffffff16565b8360010181905550613b8586858584613b8d565b505050505050565b600083600101541415613bdf5760008360000160006101000a81548160ff021916908315150217905550613bd18460090160020154826138df90919063ffffffff16565b600084600901600201819055505b600082600101541415613c215760008260000160006101000a81548160ff021916908315150217905550613c208160010154826138df90919063ffffffff16565b5b50505050565b6000808314158290613c6f576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401613c6691906155b6565b60405180910390fd5b50828481613c7957fe5b0690509392505050565b6060823073ffffffffffffffffffffffffffffffffffffffff16311015613cdf576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401613cd6906157f8565b60405180910390fd5b613ce885613daf565b613d27576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401613d1e90615a18565b60405180910390fd5b600060608673ffffffffffffffffffffffffffffffffffffffff168587604051613d51919061545f565b60006040518083038185875af1925050503d8060008114613d8e576040519150601f19603f3d011682016040523d82523d6000602084013e613d93565b606091505b5091509150613da3828286613dc2565b92505050949350505050565b600080823b905060008111915050919050565b60608315613dd257829050613e22565b600083511115613de55782518084602001fd5b816040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401613e1991906155b6565b60405180910390fd5b9392505050565b6040518060a0016040528060001515815260200160001515815260200160001515815260200160008152602001600081525090565b604051806101000160405280600015158152602001600081526020016000815260200160008152602001600081526020016000815260200160008019168152602001600080191681525090565b60405180610120016040528060001515815260200160008152602001600081526020016000815260200160008152602001600081526020016000815260200160608152602001606081525090565b6040518060400160405280613f0c613f49565b8152602001613f19613f1f565b81525090565b60405180608001604052806000151581526020016000815260200160008152602001600081525090565b6040518060c0016040528060001515815260200160008152602001600081526020016000815260200160008152602001600073ffffffffffffffffffffffffffffffffffffffff1681525090565b600081359050613fa681615e09565b92915050565b600082601f830112613fbd57600080fd5b8135613fd0613fcb82615bf3565b615bc6565b91508181835260208401935060208101905083856020840282011115613ff557600080fd5b60005b83811015614025578161400b8882614059565b845260208401935060208301925050600181019050613ff8565b5050505092915050565b60008151905061403e81615e20565b92915050565b60008135905061405381615e37565b92915050565b60008135905061406881615e4e565b92915050565b60006020828403121561408057600080fd5b600061408e84828501613f97565b91505092915050565b6000602082840312156140a957600080fd5b60006140b78482850161402f565b91505092915050565b6000602082840312156140d257600080fd5b60006140e084828501614059565b91505092915050565b600080604083850312156140fc57600080fd5b600061410a85828601614059565b925050602061411b85828601613f97565b9150509250929050565b6000806000806080858703121561413b57600080fd5b600061414987828801614059565b945050602085013567ffffffffffffffff81111561416657600080fd5b61417287828801613fac565b935050604061418387828801614059565b925050606061419487828801614059565b91505092959194509250565b600080604083850312156141b357600080fd5b60006141c185828601614059565b92505060206141d285828601614044565b9150509250929050565b600080604083850312156141ef57600080fd5b60006141fd85828601614059565b925050602061420e85828601614059565b9150509250929050565b60006142248383614278565b60208301905092915050565b600061423c83836150d0565b6101408301905092915050565b60006142558383615100565b60c08301905092915050565b61427261426d82615d0a565b615db3565b82525050565b61428181615cf8565b82525050565b61429081615cf8565b82525050565b60006142a182615c4b565b6142ab8185615ca9565b93506142b683615c1b565b8060005b838110156142e75781516142ce8882614218565b97506142d983615c82565b9250506001810190506142ba565b5085935050505092915050565b60006142ff82615c56565b6143098185615cba565b935061431483615c2b565b8060005b8381101561434557815161432c8882614230565b975061433783615c8f565b925050600181019050614318565b5085935050505092915050565b600061435d82615c61565b6143678185615ccb565b935061437283615c3b565b8060005b838110156143a357815161438a8882614249565b975061439583615c9c565b925050600181019050614376565b5085935050505092915050565b6143b981615d1c565b82525050565b6143c881615d1c565b82525050565b6143d781615d28565b82525050565b6143e681615d28565b82525050565b6143fd6143f882615d28565b615dc5565b82525050565b600061440e82615c6c565b6144188185615cdc565b9350614428818560208601615d80565b80840191505092915050565b61443d81615d5c565b82525050565b600061444e82615c77565b6144588185615ce7565b9350614468818560208601615d80565b61447181615deb565b840191505092915050565b6000614489602283615ce7565b91507f4f776e6572207375626d697474696e6720706572696f64206e6f74207061737360008301527f65640000000000000000000000000000000000000000000000000000000000006020830152604082019050919050565b60006144ef601c83615ce7565b91507f47617020696e206974657261626c6520656e7472696573206c697374000000006000830152602082019050919050565b600061452f601283615ce7565b91507f4c696d6974206e6f7420706f73697469766500000000000000000000000000006000830152602082019050919050565b600061456f601d83615ce7565b91507f52657761726420726575736564206173206e657874206a61636b706f740000006000830152602082019050919050565b60006145af601083615ce7565b91507f4e6f7468696e6720746f207265757365000000000000000000000000000000006000830152602082019050919050565b60006145ef602e83615ce7565b91507f556e61626c6520746f2072657665616c207365616c65642073656564206f6e2060008301527f7468652073616d6520626c6f636b0000000000000000000000000000000000006020830152604082019050919050565b6000614655601283615ce7565b91507f4e6f74206120726f756e642077696e6e657200000000000000000000000000006000830152602082019050919050565b6000614695601e83615ce7565b91507f52657761726420616d6f756e7420697320657175616c20746f207a65726f00006000830152602082019050919050565b60006146d5602883615ce7565b91507f4c696e6b65644c697374206765744e6f64653a20706f696e746572206f75742060008301527f6f662073636f70650000000000000000000000000000000000000000000000006020830152604082019050919050565b600061473b601883615ce7565b91507f5365616c65642073656564206e6f742070726f766964656400000000000000006000830152602082019050919050565b600061477b601b83615ce7565b91507f536166654d6174683a206164646974696f6e206f766572666c6f7700000000006000830152602082019050919050565b60006147bb601f83615ce7565b91507f496e76616c6964206578706563746564206974657261626c6520656e747279006000830152602082019050919050565b60006147fb602283615ce7565b91507f526573756c7420616c726561647920686173206265656e2063616c63756c617460008301527f65640000000000000000000000000000000000000000000000000000000000006020830152604082019050919050565b6000614861601483615ce7565b91507f4e6f7468696e6720746f2063616c63756c6174650000000000000000000000006000830152602082019050919050565b60006148a1601583615ce7565b91507f5365656420616c72656164792070726f766964656400000000000000000000006000830152602082019050919050565b60006148e1601c83615ce7565b91507f496e76616c6964206974657261626c6520656e74727920696e646578000000006000830152602082019050919050565b6000614921602283615ce7565b91507f4578706563746564206974657261626c6520656e747279206e6f74206163746960008301527f76650000000000000000000000000000000000000000000000000000000000006020830152604082019050919050565b6000614987602683615ce7565b91507f416464726573733a20696e73756666696369656e742062616c616e636520666f60008301527f722063616c6c00000000000000000000000000000000000000000000000000006020830152604082019050919050565b60006149ed601583615ce7565b91507f46726f6d20726f756e64206e6f7420636c6f73656400000000000000000000006000830152602082019050919050565b6000614a2d601683615ce7565b91507f416d6f756e74206973206e6f7420706f736974697665000000000000000000006000830152602082019050919050565b6000614a6d602483615ce7565b91507f4c696e6b65644c697374206765743a20706f696e746572206f7574206f66207360008301527f636f7065000000000000000000000000000000000000000000000000000000006020830152604082019050919050565b6000614ad3601983615ce7565b91507f526f756e642072657761726420616c72656164792070616964000000000000006000830152602082019050919050565b6000614b13601383615ce7565b91507f526f756e6420616c726561647920656e646564000000000000000000000000006000830152602082019050919050565b6000614b53602483615ce7565b91507f41626c6520746f207265757365206f6e6c7920666f722063757272656e74207260008301527f6f756e64000000000000000000000000000000000000000000000000000000006020830152604082019050919050565b6000614bb9602183615ce7565b91507f536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f60008301527f77000000000000000000000000000000000000000000000000000000000000006020830152604082019050919050565b6000614c1f603683615ce7565b91507f4d6f7265207468616e2032353620626c6f636b73207061737365642066726f6d60008301527f2070726f766964696e67207365616c65642073656564000000000000000000006020830152604082019050919050565b6000614c85601583615ce7565b91507f5365656420616c72656164792072657665616c656400000000000000000000006000830152602082019050919050565b6000614cc5602083615ce7565b91507f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726000830152602082019050919050565b6000614d05600f83615ce7565b91507f526f756e64206e6f7420666f756e6400000000000000000000000000000000006000830152602082019050919050565b6000614d45601a83615ce7565b91507f4e6f74206e6f6d696e6174656420746f206f776e6572736869700000000000006000830152602082019050919050565b6000614d85600c83615ce7565b91507f496e76616c6964207365656400000000000000000000000000000000000000006000830152602082019050919050565b6000614dc5601683615ce7565b91507f496e20726f756e6420616c726561647920656e646564000000000000000000006000830152602082019050919050565b6000614e05602783615ce7565b91507f4c696e6b65644c69737420696e736572743a20706f696e746572206f7574206f60008301527f662073636f7065000000000000000000000000000000000000000000000000006020830152604082019050919050565b6000614e6b601183615ce7565b91507f53656564206e6f742072657665616c65640000000000000000000000000000006000830152602082019050919050565b6000614eab601d83615ce7565b91507f416464726573733a2063616c6c20746f206e6f6e2d636f6e74726163740000006000830152602082019050919050565b6000614eeb602783615ce7565b91507f4c696e6b65644c6973742072656d6f76653a20706f696e746572206f7574206f60008301527f662073636f7065000000000000000000000000000000000000000000000000006020830152604082019050919050565b6000614f51603683615ce7565b91507f4c657373207468616e2032353620626c6f636b73207061737365642066726f6d60008301527f2070726f766964696e67207365616c65642073656564000000000000000000006020830152604082019050919050565b6000614fb7602a83615ce7565b91507f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008301527f6f742073756363656564000000000000000000000000000000000000000000006020830152604082019050919050565b600061501d602083615ce7565b91507f55736572732063616e20776974686472617720746865697220726577617264736000830152602082019050919050565b600061505d600f83615ce7565b91507f526f756e64206e6f7420656e64656400000000000000000000000000000000006000830152602082019050919050565b600061509d601c83615ce7565b91507f5365616c6564207365656420616c72656164792070726f7669646564000000006000830152602082019050919050565b610140820160008201516150e76000850182615100565b5060208201516150fa60c085018261517b565b50505050565b60c08201600082015161511660008501826143b0565b50602082015161512960208501826153a6565b50604082015161513c60408501826153a6565b50606082015161514f60608501826153a6565b50608082015161516260808501826153a6565b5060a082015161517560a0850182614278565b50505050565b60808201600082015161519160008501826143b0565b5060208201516151a460208501826153a6565b5060408201516151b760408501826153a6565b5060608201516151ca60608501826153a6565b50505050565b610100820160008201516151e760008501826143b0565b5060208201516151fa60208501826153a6565b50604082015161520d60408501826153a6565b50606082015161522060608501826153a6565b50608082015161523360808501826153a6565b5060a082015161524660a08501826153a6565b5060c082015161525960c08501826143ce565b5060e082015161526c60e08501826143ce565b50505050565b60a08201600082015161528860008501826143b0565b50602082015161529b60208501826143b0565b5060408201516152ae60408501826143b0565b5060608201516152c160608501826153a6565b5060808201516152d460808501826153a6565b50505050565b6000610120830160008301516152f360008601826143b0565b50602083015161530660208601826153a6565b50604083015161531960408601826153a6565b50606083015161532c60608601826153a6565b50608083015161533f60808601826153a6565b5060a083015161535260a08601826153a6565b5060c083015161536560c08601826153a6565b5060e083015184820360e086015261537d8282614296565b9150506101008301518482036101008601526153998282614296565b9150508091505092915050565b6153af81615d52565b82525050565b6153be81615d52565b82525050565b6153d56153d082615d52565b615de1565b82525050565b60006153e78285614261565b6014820191506153f782846143ec565b6020820191508190509392505050565b600061541382856143ec565b60208201915061542382846143ec565b6020820191508190509392505050565b600061543f82856143ec565b60208201915061544f82846153c4565b6020820191508190509392505050565b600061546b8284614403565b915081905092915050565b600060208201905061548b6000830184614287565b92915050565b60006060820190506154a66000830186614287565b6154b36020830185614287565b6154c060408301846153b5565b949350505050565b60006040820190506154dd6000830185614287565b6154ea60208301846153b5565b9392505050565b6000602082019050818103600083015261550b8184614352565b905092915050565b600060208201905061552860008301846143bf565b92915050565b600060208201905061554360008301846143dd565b92915050565b600060408201905061555e60008301856143dd565b61556b60208301846143dd565b9392505050565b600060408201905061558760008301856143dd565b61559460208301846153b5565b9392505050565b60006020820190506155b06000830184614434565b92915050565b600060208201905081810360008301526155d08184614443565b905092915050565b600060208201905081810360008301526155f18161447c565b9050919050565b60006020820190508181036000830152615611816144e2565b9050919050565b6000602082019050818103600083015261563181614522565b9050919050565b6000602082019050818103600083015261565181614562565b9050919050565b60006020820190508181036000830152615671816145a2565b9050919050565b60006020820190508181036000830152615691816145e2565b9050919050565b600060208201905081810360008301526156b181614648565b9050919050565b600060208201905081810360008301526156d181614688565b9050919050565b600060208201905081810360008301526156f1816146c8565b9050919050565b600060208201905081810360008301526157118161472e565b9050919050565b600060208201905081810360008301526157318161476e565b9050919050565b60006020820190508181036000830152615751816147ae565b9050919050565b60006020820190508181036000830152615771816147ee565b9050919050565b6000602082019050818103600083015261579181614854565b9050919050565b600060208201905081810360008301526157b181614894565b9050919050565b600060208201905081810360008301526157d1816148d4565b9050919050565b600060208201905081810360008301526157f181614914565b9050919050565b600060208201905081810360008301526158118161497a565b9050919050565b60006020820190508181036000830152615831816149e0565b9050919050565b6000602082019050818103600083015261585181614a20565b9050919050565b6000602082019050818103600083015261587181614a60565b9050919050565b6000602082019050818103600083015261589181614ac6565b9050919050565b600060208201905081810360008301526158b181614b06565b9050919050565b600060208201905081810360008301526158d181614b46565b9050919050565b600060208201905081810360008301526158f181614bac565b9050919050565b6000602082019050818103600083015261591181614c12565b9050919050565b6000602082019050818103600083015261593181614c78565b9050919050565b6000602082019050818103600083015261595181614cb8565b9050919050565b6000602082019050818103600083015261597181614cf8565b9050919050565b6000602082019050818103600083015261599181614d38565b9050919050565b600060208201905081810360008301526159b181614d78565b9050919050565b600060208201905081810360008301526159d181614db8565b9050919050565b600060208201905081810360008301526159f181614df8565b9050919050565b60006020820190508181036000830152615a1181614e5e565b9050919050565b60006020820190508181036000830152615a3181614e9e565b9050919050565b60006020820190508181036000830152615a5181614ede565b9050919050565b60006020820190508181036000830152615a7181614f44565b9050919050565b60006020820190508181036000830152615a9181614faa565b9050919050565b60006020820190508181036000830152615ab181615010565b9050919050565b60006020820190508181036000830152615ad181615050565b9050919050565b60006020820190508181036000830152615af181615090565b9050919050565b600061010082019050615b0e60008301846151d0565b92915050565b600060a082019050615b296000830184615272565b92915050565b60006020820190508181036000830152615b4981846152da565b905092915050565b6000602082019050615b6660008301846153b5565b92915050565b600060a082019050615b8160008301886153b5565b615b8e60208301876153b5565b615b9b60408301866153b5565b615ba860608301856153b5565b8181036080830152615bba81846142f4565b90509695505050505050565b6000604051905081810181811067ffffffffffffffff82111715615be957600080fd5b8060405250919050565b600067ffffffffffffffff821115615c0a57600080fd5b602082029050602081019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b6000602082019050919050565b6000602082019050919050565b6000602082019050919050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b6000615d0382615d32565b9050919050565b6000615d1582615d32565b9050919050565b60008115159050919050565b6000819050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b6000615d6782615d6e565b9050919050565b6000615d7982615d32565b9050919050565b60005b83811015615d9e578082015181840152602081019050615d83565b83811115615dad576000848401525b50505050565b6000615dbe82615dcf565b9050919050565b6000819050919050565b6000615dda82615dfc565b9050919050565b6000819050919050565b6000601f19601f8301169050919050565b60008160601b9050919050565b615e1281615cf8565b8114615e1d57600080fd5b50565b615e2981615d1c565b8114615e3457600080fd5b50565b615e4081615d28565b8114615e4b57600080fd5b50565b615e5781615d52565b8114615e6257600080fd5b5056fea26469706673582212200a5687aad47ae3bb2b219ac3a1b07703cc4ee097c50d6837f1195f48a11b57f764736f6c634300060c0033000000000000000000000000c3ec80343d2bae2f8e680fdadde7c17e71e114ea000000000000000000000000c2132d05d31c914a87c6611c10748aeb04b58e8f000000000000000000000000000000000000000000000000000000006153ac800000000000000000000000002f2e1f88cdc2ccbf12376708279c3b97eec33d46

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

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

ipfs://0a5687aad47ae3bb2b219ac3a1b07703cc4ee097c50d6837f1195f48a11b57f7