Contract 0x15ec4efffbc63e2919189f38302fdfe2bbe6b846

Contract Overview

Balance:
0 HT

HT Value:
$0.00

Token:
Txn Hash Method
Block
From
To
Value [Txn Fee]
0xddc99bb65cc42a4d4737a211d8f4840037f941150e758c768f2d88a0b94f3b95Withdraw(pending)2021-12-02 1:19:138 mins ago0xcd4b4a855c1826fff8aa968a94b684e2f358e310 IN 0x15ec4efffbc63e2919189f38302fdfe2bbe6b8460 HT(Pending)
0x1494f832c4ca51f52a558274369b800afb39dd9eeea9a454ff4345cf24319086Withdraw(pending)2021-12-02 1:11:1616 mins ago0xcd4b4a855c1826fff8aa968a94b684e2f358e310 IN 0x15ec4efffbc63e2919189f38302fdfe2bbe6b8460 HT(Pending)
0x07ebb6bf284f78418320b6a431600da9444b132d55aaad0ceb1adf2bfcd519deWithdraw(pending)2021-12-02 1:11:1016 mins ago0xcd4b4a855c1826fff8aa968a94b684e2f358e310 IN 0x15ec4efffbc63e2919189f38302fdfe2bbe6b8460 HT(Pending)
0xfaf1f0f8ae4a0a66f4c6667bf590589e87c9479760b40b97bde29fd06ae0b07bWithdraw(pending)2021-12-02 1:11:1016 mins ago0xcd4b4a855c1826fff8aa968a94b684e2f358e310 IN 0x15ec4efffbc63e2919189f38302fdfe2bbe6b8460 HT(Pending)
0xe9bce0e993ca74276443b8789713f6132eea88f65cc38d97657adff83fa2160bWithdraw(pending)2021-12-02 1:08:0019 mins ago0xcd4b4a855c1826fff8aa968a94b684e2f358e310 IN 0x15ec4efffbc63e2919189f38302fdfe2bbe6b8460 HT(Pending)
0xd9ca2fa9a8a919274a271e4d9b19fa48afd6a1ef29f988c932c335f0c45d9dc0Withdraw(pending)2021-12-02 1:08:0019 mins ago0xcd4b4a855c1826fff8aa968a94b684e2f358e310 IN 0x15ec4efffbc63e2919189f38302fdfe2bbe6b8460 HT(Pending)
0xf205d97b6017d0d17341ebdf25805e8702389e3c74b340a3159f62441718ef3eWithdraw(pending)2021-12-02 1:02:4225 mins ago0xcd4b4a855c1826fff8aa968a94b684e2f358e310 IN 0x15ec4efffbc63e2919189f38302fdfe2bbe6b8460 HT(Pending)
0x220cc1c7f48525c2cd0ff11ace5f35d7e8c97bc5092ab3abdcb17508780c2514Withdraw(pending)2021-12-02 1:02:4225 mins ago0xcd4b4a855c1826fff8aa968a94b684e2f358e310 IN 0x15ec4efffbc63e2919189f38302fdfe2bbe6b8460 HT(Pending)
0xb20d30564e0e6ae936050e072e93e979420a2c63b7efc8220e095d8ffc562b82Deposit(pending)2021-12-02 0:42:0645 mins ago0xe621fc920b30cc4ace7afdeb70a6371f58bb6cb2 IN 0x15ec4efffbc63e2919189f38302fdfe2bbe6b8460 HT(Pending)
0x204846ade1158caf9c19724c6f15616eed21c00e05f3ad6a3b35b5c9b3fdf553Withdraw(pending)2021-12-02 0:42:0645 mins ago0xe621fc920b30cc4ace7afdeb70a6371f58bb6cb2 IN 0x15ec4efffbc63e2919189f38302fdfe2bbe6b8460 HT(Pending)
0x7d993fbb04861a5dae64c0005dc18e218f483581d581c3c0f7d39b456ef54fb4Deposit(pending)2021-12-02 0:42:0645 mins ago0xe621fc920b30cc4ace7afdeb70a6371f58bb6cb2 IN 0x15ec4efffbc63e2919189f38302fdfe2bbe6b8460 HT(Pending)
0x0cca47816e3d3fd0dd92e99200228f2f5c9d6feab57aea33a95acd43858de9d4Deposit(pending)2021-12-02 0:42:0645 mins ago0xe621fc920b30cc4ace7afdeb70a6371f58bb6cb2 IN 0x15ec4efffbc63e2919189f38302fdfe2bbe6b8460 HT(Pending)
0x4c54bac8bed210b94bcad0a17c9138dcb984770117071418751f75b1d88d9857Deposit(pending)2021-12-02 0:42:0645 mins ago0xe621fc920b30cc4ace7afdeb70a6371f58bb6cb2 IN 0x15ec4efffbc63e2919189f38302fdfe2bbe6b8460 HT(Pending)
0xeab0ecd67e2cc9bf6a7b2767a74a169365307e598dd0783eaa86c96a60dea52eDeposit(pending)2021-12-02 0:42:0645 mins ago0xe621fc920b30cc4ace7afdeb70a6371f58bb6cb2 IN 0x15ec4efffbc63e2919189f38302fdfe2bbe6b8460 HT(Pending)
0xa9a1fae42aeaed8b05469e0f919d3c87d74a388143e179173895a36429761ffbDeposit(pending)2021-12-02 0:42:0645 mins ago0xe621fc920b30cc4ace7afdeb70a6371f58bb6cb2 IN 0x15ec4efffbc63e2919189f38302fdfe2bbe6b8460 HT(Pending)
0x9edb8469e2b7310148219911bb6f84c99814cf30dbcbe388c0535eb720bae624Deposit(pending)2021-12-02 0:42:0645 mins ago0xe621fc920b30cc4ace7afdeb70a6371f58bb6cb2 IN 0x15ec4efffbc63e2919189f38302fdfe2bbe6b8460 HT(Pending)
0x7211775c6906bbd14ba36908a8bdee124652f5f8ac848585408d6363c2dfa17bDeposit(pending)2021-12-02 0:42:0645 mins ago0xe621fc920b30cc4ace7afdeb70a6371f58bb6cb2 IN 0x15ec4efffbc63e2919189f38302fdfe2bbe6b8460 HT(Pending)
0x3c9b3b4d630b61d5700686aedce514b63ac35d4a6e82e76004a63ad5e4369580Deposit(pending)2021-12-02 0:42:0645 mins ago0xe621fc920b30cc4ace7afdeb70a6371f58bb6cb2 IN 0x15ec4efffbc63e2919189f38302fdfe2bbe6b8460 HT(Pending)
0xc523a84024be884b2a6a995a31b5084de0e0cabf5ccfac295255a18475d9641aWithdraw(pending)2021-12-02 0:42:0645 mins ago0xd2d36d128d14ce16a73d9fa1eef0fbe7f236c51c IN 0x15ec4efffbc63e2919189f38302fdfe2bbe6b8460 HT(Pending)
0xd6da5958d79151c3794fc3031dce43c89d7b9190cd3b22e84f1b1e1ceef8bb8fWithdraw(pending)2021-12-02 0:42:0645 mins ago0xd2d36d128d14ce16a73d9fa1eef0fbe7f236c51c IN 0x15ec4efffbc63e2919189f38302fdfe2bbe6b8460 HT(Pending)
0x9d48538db9a17157dbf91d4da90c48ae5d242fbc03386412aa39fc6503b3ce44Withdraw(pending)2021-12-02 0:42:0645 mins ago0xd2d36d128d14ce16a73d9fa1eef0fbe7f236c51c IN 0x15ec4efffbc63e2919189f38302fdfe2bbe6b8460 HT(Pending)
0x2e5d723cf78a53b2f9758903ee0fa96a6fab4cd66f39da3c8975cd8cadc51e2aWithdraw(pending)2021-12-02 0:42:0645 mins ago0xd2d36d128d14ce16a73d9fa1eef0fbe7f236c51c IN 0x15ec4efffbc63e2919189f38302fdfe2bbe6b8460 HT(Pending)
0x37829d8dbd238d38e1361fdc39ddfa5eec44a23536a44761ae01eb12bd2999fdWithdraw(pending)2021-12-02 0:42:0645 mins ago0xd2d36d128d14ce16a73d9fa1eef0fbe7f236c51c IN 0x15ec4efffbc63e2919189f38302fdfe2bbe6b8460 HT(Pending)
0x8305fe689b04e5f6ea125583d4d48c92d5bdd11ea90ebfc74a1bde424147c1bdWithdraw(pending)2021-12-02 0:42:0645 mins ago0xd2d36d128d14ce16a73d9fa1eef0fbe7f236c51c IN 0x15ec4efffbc63e2919189f38302fdfe2bbe6b8460 HT(Pending)
0x0c665e78b40bdd036fd80651754e264c59b569b094eb0e9f97eff37b189d1f32Withdraw(pending)2021-12-02 0:42:0645 mins ago0xd2d36d128d14ce16a73d9fa1eef0fbe7f236c51c IN 0x15ec4efffbc63e2919189f38302fdfe2bbe6b8460 HT(Pending)
Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
RewardPools

Compiler Version
v0.5.16+commit.9c3226ce

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, None license

Contract Source Code (Solidity)

/**
 *Submitted for verification at hecoinfo.com on 2021-03-24
*/

// File: @openzeppelin/contracts/math/Math.sol
//pragma experimental ABIEncoderV2;
pragma solidity ^0.5.16;

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

// File: @openzeppelin/contracts/math/SafeMath.sol

pragma solidity ^0.5.16;

/**
 * @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.
     *
     * _Available since v2.4.0._
     */
    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.
     *
     * _Available since v2.4.0._
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        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.
     *
     * _Available since v2.4.0._
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

// File: @openzeppelin/contracts/GSN/Context.sol

pragma solidity ^0.5.16;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
contract Context {
    // Empty internal constructor, to prevent people from mistakenly deploying
    // an instance of this contract, which should be used via inheritance.
    constructor () internal { }
    // solhint-disable-previous-line no-empty-blocks

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

    function _msgData() internal view returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

// File: @openzeppelin/contracts/ownership/Ownable.sol

pragma solidity ^0.5.16;

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        _owner = _msgSender();
        emit OwnershipTransferred(address(0), _owner);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(isOwner(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Returns true if the caller is the current owner.
     */
    function isOwner() public view returns (bool) {
        return _msgSender() == _owner;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     */
    function _transferOwnership(address newOwner) internal {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol

pragma solidity ^0.5.16;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP. Does not include
 * the optional functions; to access them see {ERC20Detailed}.
 */
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);
    function mint(address account, uint amount) external;

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

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

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

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

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

// File: @openzeppelin/contracts/utils/Address.sol

pragma solidity ^0.5.16;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * This test is non-exhaustive, and there may be false-negatives: during the
     * execution of a contract's constructor, its address will be reported as
     * not containing 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.
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies in extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != 0x0 && codehash != accountHash);
    }

    /**
     * @dev Converts an `address` into `address payable`. Note that this is
     * simply a type cast: the actual underlying value is not changed.
     *
     * _Available since v2.4.0._
     */
    function toPayable(address account) internal pure returns (address payable) {
        return address(uint160(account));
    }

    /**
     * @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].
     *
     * _Available since v2.4.0._
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

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

// File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol

pragma solidity ^0.5.16;




/**
 * @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 ERC20;` 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));
    }

    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.

        // A Solidity high level call has three parts:
        //  1. The target address is checked to verify it contains contract code
        //  2. The call itself is made, and success asserted
        //  3. The return value is decoded, which in turn checks the size of the returned data.
        // solhint-disable-next-line max-line-length
        require(address(token).isContract(), "SafeERC20: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = address(token).call(data);
        require(success, "SafeERC20: low-level call failed");

        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// File: contracts/IRewardDistributionRecipient.sol

pragma solidity ^0.5.16;



contract IRewardDistributionRecipient is Ownable {
    address public rewardDistribution;

    //function notifyRewardAmount(uint256 reward) external;

    modifier onlyRewardDistribution() {
        require(_msgSender() == rewardDistribution, "Caller is not reward distribution");
        _;
    }

    function setRewardDistribution(address _rewardDistribution)
        external
        onlyOwner
    {
        rewardDistribution = _rewardDistribution;
    }
}


/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;

        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping (bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) { // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            bytes32 lastvalue = set._values[lastIndex];

            // Move the last value to the index where the value to delete is
            set._values[toDeleteIndex] = lastvalue;
            // Update the index for the moved value
            set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        require(set._values.length > index, "EnumerableSet: index out of bounds");
        return set._values[index];
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint256(_at(set._inner, index)));
    }


    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }
}

interface IRewardPools {
    function deposit(uint256 pid, uint256 time, uint256 amount) external;
    function withdraw(uint256 pid, uint256 amount) external;
    function earned(uint256 rid, uint256 pid, address account) external view returns(uint256);
    function getTokenAmount(address account, address token) external view returns(uint256);
    function getTokenIsInMembers(address token) external view returns(bool);
    function getTokenMember(uint256 index) external view returns(address);
    function getTokenMembersLength() external view returns(uint256);
    function isVote() external view returns(bool);
    function lastTimeRewardApplicable(uint256 rid, uint256 pid) external view returns(uint256);
    function poolUse(uint256 pid) external view returns(IERC20, uint256, uint256, uint256, uint256);
    function rewardPerToken(uint256 rid, uint256 pid) external view returns(uint256);
    function totalID() external view returns(uint256);
    function isDeposit(uint256 pid, address account) external view returns(bool);
    function depositNum(uint256 pid) external view returns(uint256);
    function user(uint256 pid, address account) external view returns(uint256, uint256, uint256, uint256, uint256);
    function userInfo(uint256 rid, uint256 pid, address account) external view returns(uint256, uint256);
    function poolInfo(uint256 rid, uint256 pid) external view returns(uint256, uint256, uint256, uint256, uint256, uint256);
}

contract RewardPools is IRewardDistributionRecipient, IRewardPools {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;
    using EnumerableSet for EnumerableSet.AddressSet;
    
    uint256 public totalID;
    uint256 oneMonth = 30 days;
    uint256 threeYear = 3 * 12 * oneMonth;
    bool public isVote;
    EnumerableSet.AddressSet rewardToken;

    struct PoolInfo {
        uint256 initreward;
        uint256 rewardRate;
        uint256 lastUpdateTime;
        uint256 rewardPerTokenStored;
        uint256 periodFinish;
    }

    struct UserInfo {
        uint256 userRewardPerTokenPaid;
        uint256 rewards;
    }

    struct PoolUse {
        IERC20 lpToken;
        uint256 totalSupply;
        uint256 duration;
        uint256 totalTime;
        uint256 weight;
    }

    struct User {
        uint256 balances;
        uint256 lastTime;
        uint256 choiceTime;
        uint256 endTime;
        uint256 weight;
    }

    // pid => poolUse
    mapping (uint256 => PoolUse) public poolUse;
    // pid => user => user
    mapping (uint256 => mapping(address => User)) public user;
    // rid => pid => reward
    mapping (uint256 => mapping(uint256 => PoolInfo)) public poolInfo;
    // rid => pid => user => userInfo
    mapping(uint256 => mapping(uint256 => mapping(address => UserInfo))) public userInfo;
    mapping(uint256 => mapping(address => bool)) public isDeposit;
    mapping(uint256 => uint256) public depositNum;

    event RewardAdded(uint256 rid, uint256 pid, uint256 reward);
    event Deposit(address indexed user, uint256 pid, uint256 amount);
    event Withdrawn(address indexed user, uint256 pid, uint256 amount);
    event RewardPaid(address indexed user, uint256 rid, uint256 pid, uint256 reward);
    event VoteTime(bool _isVote);

    constructor() public {}
    

    modifier updateReward(uint256 pid, address account) {
        uint256 rid = getTokenMembersLength();
        for(uint256 i = 0; i < rid; i++) {
            poolInfo[i][pid].rewardPerTokenStored = rewardPerToken(i, pid);
            poolInfo[i][pid].lastUpdateTime = lastTimeRewardApplicable(i, pid);
            if (account != address(0)) {
                userInfo[i][pid][account].rewards = earned(i, pid, account);
                userInfo[i][pid][account].userRewardPerTokenPaid = poolInfo[i][pid].rewardPerTokenStored;
            }
        }
        _;
    }

    modifier isPidExist(uint256 pid) {
        require(pid < totalID, "pid not exist");
        _;
    }

    modifier isRidExist(uint256 rid) {
        require(rid < getTokenMembersLength(), "rid not exist");
        _;
    }
    
    modifier notVote() {
        require(!isVote, "time is vote statistical");
        _;
    }

    function addDepositToken(IERC20 token, uint256 duration) 
        public 
        onlyOwner  
        returns(uint256 pid) 
    {
        pid = totalID++;
        poolUse[pid] = PoolUse({
            lpToken: token,
            totalSupply: 0,
            duration: duration,
            totalTime: 0,
            weight: 0
        });
    }

    function addRewardToken(address token) public onlyOwner returns(bool) {
        if(!rewardToken.contains(token)) {
            rewardToken.add(token);
        }
        return true;
    }

    function getTokenAmount(address account, address token) public view returns(uint256) {
        return IERC20(token).balanceOf(account);
    }
    
    function getTokenMember(uint256 index) public view returns(address) {
        return rewardToken.at(index);
    }
    
    function getTokenMembersLength() public view returns(uint256) {
        return rewardToken.length();
    }
    
    function getTokenIsInMembers(address token) public view returns(bool) {
        return rewardToken.contains(token);
    }

    function lastTimeRewardApplicable(uint256 rid, uint256 pid) 
        public 
        isPidExist(pid) 
        view 
        returns (uint256) 
    {
        return Math.min(block.timestamp, poolInfo[rid][pid].periodFinish);
    }

    function rewardPerToken(uint256 rid, uint256 pid) public isPidExist(pid) view returns (uint256) {
        if (poolUse[pid].weight == 0) {
            return poolInfo[rid][pid].rewardPerTokenStored;
        }
        return
            poolInfo[rid][pid].rewardPerTokenStored.add(
                lastTimeRewardApplicable(rid, pid)
                    .sub(poolInfo[rid][pid].lastUpdateTime)
                    .mul(poolInfo[rid][pid].rewardRate)
                    .mul(1e36)
                    .div(poolUse[pid].weight)
            );
    }

    function earned(uint256 rid, uint256 pid, address account) public view returns (uint256) {
        return
            user[pid][account].weight
                .mul(rewardPerToken(rid, pid).sub(userInfo[rid][pid][account].userRewardPerTokenPaid))
                .div(1e36)
                .add(userInfo[rid][pid][account].rewards);
    }

    function deposit(uint256 pid, uint256 time, uint256 amount) 
        public 
        isPidExist(pid) 
        notVote
        updateReward(pid, msg.sender) 
    {
        require(amount > 0, "amount cant not less than 0");
        require(time/oneMonth >= 1, "time shoud >= oneMonth");

        stake(pid, time, amount);
        emit Deposit(msg.sender, pid, amount);
        
        if(!isDeposit[pid][msg.sender]) {
            isDeposit[pid][msg.sender] = true;
            depositNum[pid]++;
        }
    }

    function withdraw(uint256 pid, uint256 amount) 
        public 
        isPidExist(pid)
        notVote
        updateReward(pid, msg.sender) 
    {
        require(amount >= 0, "amount cant not less than 0");
        if(amount > 0) {
            require(block.timestamp > user[pid][msg.sender].endTime, "can not unlock");
        }
        uint256 rid = getTokenMembersLength();
        for(uint256 i = 0; i < rid; i++) {
            _getReward(i, pid);   
        }

        if (amount > 0) {
            withdraws(pid, amount);
            emit Withdrawn(msg.sender, pid, amount);
        }
        
        if(isDeposit[pid][msg.sender] && user[pid][msg.sender].balances == 0) {
            isDeposit[pid][msg.sender] = false;
            if(depositNum[pid] > 0) {
                depositNum[pid]--;    
            }
        }
    }

    function _getReward(uint256 rid, uint256 pid) internal {
        uint256 reward = earned(rid, pid, msg.sender);
        if (reward > 0) {
            userInfo[rid][pid][msg.sender].rewards = 0;
            poolInfo[rid][pid].initreward = poolInfo[rid][pid].initreward.sub(reward);
            IERC20(getTokenMember(rid)).safeTransfer(msg.sender, reward);
            emit RewardPaid(msg.sender, rid, pid, reward);
        }
    }

    function notifyRewardAmount(uint256 reward, uint256 rid, uint256 pid)
        external
        isRidExist(rid)
        isPidExist(pid)
        onlyRewardDistribution
        updateReward(pid, address(0))
    {
        PoolInfo storage pool = poolInfo[rid][pid];
        uint256 _currTime = block.timestamp; 
        if (_currTime >= pool.periodFinish) {
            pool.rewardRate = reward.div(poolUse[pid].duration);
        } else {
            uint256 remaining = pool.periodFinish.sub(block.timestamp);
            uint256 leftover = remaining.mul(pool.rewardRate);
            pool.rewardRate = reward.add(leftover).div(poolUse[pid].duration);
        }

        address token = getTokenMember(rid);
        IERC20(token).safeTransferFrom(msg.sender, address(this), reward);

        pool.initreward = pool.initreward.add(reward);
        pool.lastUpdateTime = _currTime;
        pool.periodFinish = _currTime.add(poolUse[pid].duration);
        emit RewardAdded(rid, pid, reward);
    }



    function stake(uint256 pid, uint256 time, uint256 amount) internal {
        if(time > threeYear) {
            time = threeYear;
        }
        poolUse[pid].totalSupply = poolUse[pid].totalSupply.add(amount);
        user[pid][msg.sender].balances = user[pid][msg.sender].balances.add(amount);

        uint256 _currTime = block.timestamp;
        uint256 _totalWeight = poolUse[pid].weight;
        if(_currTime > user[pid][msg.sender].endTime) {
            _totalWeight = _totalWeight.sub(user[pid][msg.sender].weight);
            poolUse[pid].totalTime = poolUse[pid].totalTime.sub(user[pid][msg.sender].choiceTime).add(time);
            user[pid][msg.sender].choiceTime = time;
            user[pid][msg.sender].endTime = _currTime.add(time);
            user[pid][msg.sender].lastTime = _currTime;
            user[pid][msg.sender].weight = user[pid][msg.sender].balances.mul(time);
            _totalWeight = _totalWeight.add(user[pid][msg.sender].weight);
            poolUse[pid].weight = _totalWeight;
        } else {
            _totalWeight = _totalWeight.sub(user[pid][msg.sender].weight);
            uint256 _useTime = _currTime.sub(user[pid][msg.sender].lastTime);
            uint256 _remainTime = 0;
            if(_useTime <= user[pid][msg.sender].choiceTime) {
                _remainTime = user[pid][msg.sender].choiceTime.sub(_useTime);
            }
            poolUse[pid].totalTime = poolUse[pid].totalTime.sub(user[pid][msg.sender].choiceTime);

            user[pid][msg.sender].choiceTime = _remainTime.add(time);
            if(user[pid][msg.sender].choiceTime > threeYear) {
                user[pid][msg.sender].choiceTime = threeYear;
            }
            
            user[pid][msg.sender].endTime = user[pid][msg.sender].choiceTime.add(_currTime);
            user[pid][msg.sender].lastTime = _currTime;
            user[pid][msg.sender].weight = user[pid][msg.sender].balances.mul(user[pid][msg.sender].choiceTime);

            poolUse[pid].totalTime = poolUse[pid].totalTime.add(user[pid][msg.sender].choiceTime);
            _totalWeight = _totalWeight.add(user[pid][msg.sender].weight);
            poolUse[pid].weight = _totalWeight;
        }
        
        poolUse[pid].lpToken.safeTransferFrom(msg.sender, address(this), amount);
    }

    function withdraws(uint256 pid, uint256 amount) internal {
        uint256 _totalWeight = poolUse[pid].weight;
        _totalWeight = _totalWeight.sub(user[pid][msg.sender].weight);

        poolUse[pid].totalSupply = poolUse[pid].totalSupply.sub(amount);
        user[pid][msg.sender].balances = user[pid][msg.sender].balances.sub(amount);

        uint256 _currTime = block.timestamp;
        user[pid][msg.sender].lastTime = _currTime;

        user[pid][msg.sender].weight = user[pid][msg.sender].balances.mul(user[pid][msg.sender].choiceTime);
        _totalWeight = _totalWeight.add(user[pid][msg.sender].weight);
        poolUse[pid].weight = _totalWeight;

        if(amount > 0) {
            poolUse[pid].lpToken.safeTransfer(msg.sender, amount);
        }
    }

    // seconds
    function setDuration(uint256 pid, uint256 newDuration) 
        public 
        isPidExist(pid)
        updateReward(pid, address(0))
        onlyOwner
    {
        require(newDuration > 0, "new duration shoud bigger than zero");
        uint256 num = getTokenMembersLength();
        uint256 _currTime = block.timestamp; 

        for(uint256 i = 0; i < num; i++) {
            PoolInfo storage pool = poolInfo[i][pid];
            if (_currTime < pool.periodFinish) {
                if(newDuration < poolUse[pid].duration) {
                    uint256 startTime = pool.periodFinish.sub(poolUse[pid].duration);
                    require(startTime.add(newDuration) > _currTime, "new end time < old end time");
                }
                
                uint256 remaining = pool.periodFinish.sub(_currTime);
                uint256 leftover = remaining.mul(pool.rewardRate);
                pool.rewardRate = leftover.div(newDuration);
                pool.lastUpdateTime = _currTime;
                pool.periodFinish = _currTime.add(newDuration);
            }
        }
        poolUse[pid].duration = newDuration;
    }
    
    function setVote(bool _isVote) public onlyOwner {
        isVote = _isVote;
        emit VoteTime(_isVote);
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"rid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"rid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"_isVote","type":"bool"}],"name":"VoteTime","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdrawn","type":"event"},{"constant":false,"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"uint256","name":"duration","type":"uint256"}],"name":"addDepositToken","outputs":[{"internalType":"uint256","name":"pid","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"addRewardToken","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"pid","type":"uint256"},{"internalType":"uint256","name":"time","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"deposit","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"depositNum","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"rid","type":"uint256"},{"internalType":"uint256","name":"pid","type":"uint256"},{"internalType":"address","name":"account","type":"address"}],"name":"earned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"token","type":"address"}],"name":"getTokenAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"getTokenIsInMembers","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getTokenMember","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getTokenMembersLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"isDeposit","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"isVote","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"rid","type":"uint256"},{"internalType":"uint256","name":"pid","type":"uint256"}],"name":"lastTimeRewardApplicable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"reward","type":"uint256"},{"internalType":"uint256","name":"rid","type":"uint256"},{"internalType":"uint256","name":"pid","type":"uint256"}],"name":"notifyRewardAmount","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"uint256","name":"initreward","type":"uint256"},{"internalType":"uint256","name":"rewardRate","type":"uint256"},{"internalType":"uint256","name":"lastUpdateTime","type":"uint256"},{"internalType":"uint256","name":"rewardPerTokenStored","type":"uint256"},{"internalType":"uint256","name":"periodFinish","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolUse","outputs":[{"internalType":"contract IERC20","name":"lpToken","type":"address"},{"internalType":"uint256","name":"totalSupply","type":"uint256"},{"internalType":"uint256","name":"duration","type":"uint256"},{"internalType":"uint256","name":"totalTime","type":"uint256"},{"internalType":"uint256","name":"weight","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"renounceOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"rewardDistribution","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"rid","type":"uint256"},{"internalType":"uint256","name":"pid","type":"uint256"}],"name":"rewardPerToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"pid","type":"uint256"},{"internalType":"uint256","name":"newDuration","type":"uint256"}],"name":"setDuration","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_rewardDistribution","type":"address"}],"name":"setRewardDistribution","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"bool","name":"_isVote","type":"bool"}],"name":"setVote","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"totalID","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"user","outputs":[{"internalType":"uint256","name":"balances","type":"uint256"},{"internalType":"uint256","name":"lastTime","type":"uint256"},{"internalType":"uint256","name":"choiceTime","type":"uint256"},{"internalType":"uint256","name":"endTime","type":"uint256"},{"internalType":"uint256","name":"weight","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"userRewardPerTokenPaid","type":"uint256"},{"internalType":"uint256","name":"rewards","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"pid","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"}]

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

Deployed ByteCode Sourcemap

31586:12397:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;31586:12397:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36654:528;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;36654:528:0;;;;;;;;;;;;:::i;:::-;;38506:1017;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;38506:1017:0;;;;;;;;;;;;:::i;20357:161::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;20357:161:0;-1:-1:-1;;;;;20357:161:0;;:::i;20099:33::-;;;:::i;:::-;;;;-1:-1:-1;;;;;20099:33:0;;;;;;;;;;;;;;34761:192;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;34761:192:0;-1:-1:-1;;;;;34761:192:0;;:::i;:::-;;;;;;;;;;;;;;;;;;32684:57;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;32684:57:0;;;;;;-1:-1:-1;;;;;32684:57:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32606:43;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;32606:43:0;;:::i;:::-;;;;-1:-1:-1;;;;;32606:43:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37190:863;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;37190:863:0;;;;;;;:::i;34961:143::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;34961:143:0;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;33047:45;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;33047:45:0;;:::i;35243:108::-;;;:::i;36302:344::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;36302:344:0;;;;;;;;;;;-1:-1:-1;;;;;36302:344:0;;:::i;9318:140::-;;;:::i;35363:123::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;35363:123:0;-1:-1:-1;;;;;35363:123:0;;:::i;32979:61::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;32979:61:0;;;;;;-1:-1:-1;;;;;32979:61:0;;:::i;8507:79::-;;;:::i;8873:94::-;;;:::i;34399:354::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;34399:354:0;;;;;;;;:::i;35494:236::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;35494:236:0;;;;;;;:::i;32888:84::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;32888:84:0;;;;;;;;;;;-1:-1:-1;;;;;32888:84:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;31787:22;;;:::i;42691:1161::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;42691:1161:0;;;;;;;:::i;35738:556::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;35738:556:0;;;;;;;:::i;32777:65::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;32777:65:0;;;;;;;:::i;43864:116::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;43864:116:0;;;;:::i;35116:115::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;35116:115:0;;:::i;9613:109::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;9613:109:0;-1:-1:-1;;;;;9613:109:0;;:::i;31893:18::-;;;:::i;36654:528::-;36752:3;34113:7;;34107:3;:13;34099:39;;;;;-1:-1:-1;;;34099:39:0;;;;;;;;;;;;-1:-1:-1;;;34099:39:0;;;;;;;;;;;;;;;34336:6;;;;34335:7;34327:44;;;;;-1:-1:-1;;;34327:44:0;;;;;;;;;;;;-1:-1:-1;;;34327:44:0;;;;;;;;;;;;;;;36797:3;36802:10;33535:11;33549:23;:21;:23::i;:::-;33535:37;-1:-1:-1;33587:9:0;33583:445;33606:3;33602:1;:7;33583:445;;;33671:22;33686:1;33689:3;33671:14;:22::i;:::-;33631:11;;;;:8;:11;;;;;;;;:16;;;;;;;;:37;;:62;33742:32;33640:1;33643:3;33742:24;:32::i;:::-;33708:11;;;;:8;:11;;;;;;;;:16;;;;;;;;:31;;:66;-1:-1:-1;;;;;33793:21:0;;;33789:228;;33871:23;33878:1;33881:3;33886:7;33871:6;:23::i;:::-;33835:11;;;;:8;:11;;;;;;;;:16;;;;;;;;-1:-1:-1;;;;;33835:25:0;;;;;;;;;;;:33;;;:59;;;;33964:11;;;:8;:11;;;;;:16;;;;;;;;:37;;;33913:25;;;;;;;:88;;33789:228;33611:3;;33583:445;;;;36848:1;36839:6;:10;36831:50;;;;;-1:-1:-1;;;36831:50:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;36917:1;36905:8;;36900:4;:13;;;;;;:18;;36892:53;;;;;-1:-1:-1;;;36892:53:0;;;;;;;;;;;;-1:-1:-1;;;36892:53:0;;;;;;;;;;;;;;;36958:24;36964:3;36969:4;36975:6;36958:5;:24::i;:::-;36998:32;;;;;;;;;;;;;;37006:10;;36998:32;;;;;;;;37055:14;;;;:9;:14;;;;;;;;37070:10;37055:26;;;;;;;;;;37051:124;;37098:14;;;;:9;:14;;;;;;;;37113:10;37098:26;;;;;;;:33;;-1:-1:-1;;37098:33:0;37127:4;37098:33;;;;;;37146:15;;;:10;:15;;;;;;:17;;;;;;;37051:124;34382:1;;;36654:528;;;;:::o;38506:1017::-;38614:3;34224:23;:21;:23::i;:::-;34218:3;:29;34210:55;;;;;-1:-1:-1;;;34210:55:0;;;;;;;;;;;;-1:-1:-1;;;34210:55:0;;;;;;;;;;;;;;;38639:3;34113:7;;34107:3;:13;34099:39;;;;;-1:-1:-1;;;34099:39:0;;;;;;;;;;;;-1:-1:-1;;;34099:39:0;;;;;;;;;;;;;;;20273:18;;-1:-1:-1;;;;;20273:18:0;20257:12;:10;:12::i;:::-;-1:-1:-1;;;;;20257:34:0;;20249:80;;;;-1:-1:-1;;;20249:80:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38698:3;38711:1;33535:11;33549:23;:21;:23::i;:::-;33535:37;-1:-1:-1;33587:9:0;33583:445;33606:3;33602:1;:7;33583:445;;;33671:22;33686:1;33689:3;33671:14;:22::i;:::-;33631:11;;;;:8;:11;;;;;;;;:16;;;;;;;;:37;;:62;33742:32;33640:1;33643:3;33742:24;:32::i;:::-;33708:11;;;;:8;:11;;;;;;;;:16;;;;;;;;:31;;:66;-1:-1:-1;;;;;33793:21:0;;;33789:228;;33871:23;33878:1;33881:3;33886:7;33871:6;:23::i;:::-;33835:11;;;;:8;:11;;;;;;;;:16;;;;;;;;-1:-1:-1;;;;;33835:25:0;;;;;;;;;;;:33;;;:59;;;;33964:11;;;:8;:11;;;;;:16;;;;;;;;:37;;;33913:25;;;;;;;:88;;33789:228;33611:3;;33583:445;;;-1:-1:-1;38731:21:0;38755:13;;;:8;:13;;;;;;;;:18;;;;;;;;38848:17;;;;38804:15;;38835:30;;38831:349;;38911:12;;;;:7;:12;;;;;:21;;;38900:33;;:6;;:33;:10;:33;:::i;:::-;38882:15;;;:51;38831:349;;;38986:17;;;;38966;;38986:38;;39008:15;38986:38;:21;:38;:::i;:::-;38966:58;;39039:16;39058:30;39072:4;:15;;;39058:9;:13;;:30;;;;:::i;:::-;39146:12;;;;:7;:12;;;;;:21;;;39039:49;;-1:-1:-1;39121:47:0;;:20;:6;39039:49;39121:20;:10;:20;:::i;:::-;:24;:47;:24;:47;:::i;:::-;39103:15;;;:65;-1:-1:-1;;38831:349:0;39192:13;39208:19;39223:3;39208:14;:19::i;:::-;39192:35;-1:-1:-1;39238:65:0;-1:-1:-1;;;;;39238:30:0;;39269:10;39289:4;39296:6;39238:65;:30;:65;:::i;:::-;39334:15;;:27;;39354:6;39334:27;:19;:27;:::i;:::-;39316:45;;39372:19;;;;:31;;;39316:15;39448:12;;;:7;:12;;;;;:21;;39434:36;;39394:9;;39434:36;:13;:36;:::i;:::-;39414:17;;;:56;39486:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34038:1;;;20340;;;34276;38506:1017;;;;:::o;20357:161::-;8719:9;:7;:9::i;:::-;8711:54;;;;;-1:-1:-1;;;8711:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;8711:54:0;;;;;;;;;;;;;;;20470:18;:40;;-1:-1:-1;;;;;;20470:40:0;-1:-1:-1;;;;;20470:40:0;;;;;;;;;;20357:161::o;20099:33::-;;;-1:-1:-1;;;;;20099:33:0;;:::o;34761:192::-;34825:4;8719:9;:7;:9::i;:::-;8711:54;;;;;-1:-1:-1;;;8711:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;8711:54:0;;;;;;;;;;;;;;;34846:27;:11;34867:5;34846:27;:20;:27;:::i;:::-;34842:82;;34890:22;:11;34906:5;34890:22;:15;:22;:::i;:::-;;34842:82;-1:-1:-1;34941:4:0;34761:192;;;:::o;32684:57::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;32606:43::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;32606:43:0;;;;;;;;;;:::o;37190:863::-;37275:3;34113:7;;34107:3;:13;34099:39;;;;;-1:-1:-1;;;34099:39:0;;;;;;;;;;;;-1:-1:-1;;;34099:39:0;;;;;;;;;;;;;;;34336:6;;;;34335:7;34327:44;;;;;-1:-1:-1;;;34327:44:0;;;;;;;;;;;;-1:-1:-1;;;34327:44:0;;;;;;;;;;;;;;;37319:3;37324:10;33535:11;33549:23;:21;:23::i;:::-;33535:37;-1:-1:-1;33587:9:0;33583:445;33606:3;33602:1;:7;33583:445;;;33671:22;33686:1;33689:3;33671:14;:22::i;:::-;33631:11;;;;:8;:11;;;;;;;;:16;;;;;;;;:37;;:62;33742:32;33640:1;33643:3;33742:24;:32::i;:::-;33708:11;;;;:8;:11;;;;;;;;:16;;;;;;;;:31;;:66;-1:-1:-1;;;;;33793:21:0;;;33789:228;;33871:23;33878:1;33881:3;33886:7;33871:6;:23::i;:::-;33835:11;;;;:8;:11;;;;;;;;:16;;;;;;;;-1:-1:-1;;;;;33835:25:0;;;;;;;;;;;:33;;;:59;;;;33964:11;;;:8;:11;;;;;:16;;;;;;;;:37;;;33913:25;;;;;;;:88;;33789:228;33611:3;;33583:445;;;-1:-1:-1;37418:10:0;;37415:116;;37471:9;;;;:4;:9;;;;;;;;37481:10;37471:21;;;;;;;:29;;;37453:15;:47;37445:74;;;;;-1:-1:-1;;;37445:74:0;;;;;;;;;;;;-1:-1:-1;;;37445:74:0;;;;;;;;;;;;;;;37541:11;37555:23;:21;:23::i;:::-;37541:37;-1:-1:-1;37593:9:0;37589:81;37612:3;37608:1;:7;37589:81;;;37637:18;37648:1;37651:3;37637:10;:18::i;:::-;37617:3;;37589:81;;;-1:-1:-1;37686:10:0;;37682:119;;37713:22;37723:3;37728:6;37713:9;:22::i;:::-;37755:34;;;;;;;;;;;;;;37765:10;;37755:34;;;;;;;;37682:119;37824:14;;;;:9;:14;;;;;;;;37839:10;37824:26;;;;;;;;;;:65;;;;-1:-1:-1;37854:9:0;;;;:4;:9;;;;;;;;37864:10;37854:21;;;;;;;:30;:35;37824:65;37821:225;;;37935:5;37906:14;;;:9;:14;;;;;;;;37921:10;37906:26;;;;;;;:34;;-1:-1:-1;;37906:34:0;;;37958:15;;;:10;:15;;;;;;:19;37955:80;;-1:-1:-1;;;37998:15:0;;;;-1:-1:-1;;37998:10:0;:15;;-1:-1:-1;37998:15:0;;;:17;;-1:-1:-1;;37998:17:0;;;37190:863::o;34961:143::-;35037:7;35071:5;-1:-1:-1;;;;;35064:23:0;;35088:7;35064:32;;;;;;;;;;;;;-1:-1:-1;;;;;35064:32:0;-1:-1:-1;;;;;35064:32:0;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;35064:32:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;35064:32:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;35064:32:0;;-1:-1:-1;34961:143:0;;;;;:::o;33047:45::-;;;;;;;;;;;;;:::o;35243:108::-;35296:7;35323:20;:11;:18;:20::i;:::-;35316:27;;35243:108;:::o;36302:344::-;36382:7;36602:13;;;:8;:13;;;;;;;;:18;;;;;;;;-1:-1:-1;;;;;36602:27:0;;;;;;;;;:35;;;;36499:50;;36422:216;;36602:35;36422:157;;36574:4;;36422:129;;36470:80;;:24;36602:13;:18;36470:14;:24::i;:::-;:28;:80;:28;:80;:::i;:::-;36422:9;;;;:4;:9;;;;;;;;-1:-1:-1;;;;;36422:18:0;;;;;;;;;:25;;;;:129;:47;:129;:::i;:157::-;:179;:216;:179;:216;:::i;:::-;36402:236;36302:344;-1:-1:-1;;;;36302:344:0:o;9318:140::-;8719:9;:7;:9::i;:::-;8711:54;;;;;-1:-1:-1;;;8711:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;8711:54:0;;;;;;;;;;;;;;;9417:1;9401:6;;9380:40;;-1:-1:-1;;;;;9401:6:0;;;;9380:40;;9417:1;;9380:40;9448:1;9431:19;;-1:-1:-1;;;;;;9431:19:0;;;9318:140::o;35363:123::-;35427:4;35451:27;:11;35472:5;35451:27;:20;:27;:::i;32979:61::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;8507:79::-;8545:7;8572:6;-1:-1:-1;;;;;8572:6:0;8507:79;:::o;8873:94::-;8913:4;8953:6;;-1:-1:-1;;;;;8953:6:0;8937:12;:10;:12::i;:::-;-1:-1:-1;;;;;8937:22:0;;8930:29;;8873:94;:::o;34399:354::-;34512:11;8719:9;:7;:9::i;:::-;8711:54;;;;;-1:-1:-1;;;8711:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;8711:54:0;;;;;;;;;;;;;;;-1:-1:-1;34548:7:0;:9;;;;;;;;34583:162;;;;;;;;-1:-1:-1;;;;;34583:162:0;;;;;-1:-1:-1;34583:162:0;;;;;;;;;;;;;;;;;;;;;;;;;34568:12;;;:7;:12;;;;;;;:177;;;;-1:-1:-1;;;;;;34568:177:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34548:9;34399:354::o;35494:236::-;35631:7;35592:3;34113:7;;34107:3;:13;34099:39;;;;;-1:-1:-1;;;34099:39:0;;;;;;;;;;;;-1:-1:-1;;;34099:39:0;;;;;;;;;;;;;;;35690:13;;;;:8;:13;;;;;;;;:18;;;;;;;;:31;;;35664:58;;35673:15;;35664:8;:58::i;:::-;35657:65;;34149:1;35494:236;;;;;:::o;32888:84::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;31787:22::-;;;;:::o;42691:1161::-;42784:3;34113:7;;34107:3;:13;34099:39;;;;;-1:-1:-1;;;34099:39:0;;;;;;;;;;;;-1:-1:-1;;;34099:39:0;;;;;;;;;;;;;;;42811:3;42824:1;33535:11;33549:23;:21;:23::i;:::-;33535:37;-1:-1:-1;33587:9:0;33583:445;33606:3;33602:1;:7;33583:445;;;33671:22;33686:1;33689:3;33671:14;:22::i;:::-;33631:11;;;;:8;:11;;;;;;;;:16;;;;;;;;:37;;:62;33742:32;33640:1;33643:3;33742:24;:32::i;:::-;33708:11;;;;:8;:11;;;;;;;;:16;;;;;;;;:31;;:66;-1:-1:-1;;;;;33793:21:0;;;33789:228;;33871:23;33878:1;33881:3;33886:7;33871:6;:23::i;:::-;33835:11;;;;:8;:11;;;;;;;;:16;;;;;;;;-1:-1:-1;;;;;33835:25:0;;;;;;;;;;;:33;;;:59;;;;33964:11;;;:8;:11;;;;;:16;;;;;;;;:37;;;33913:25;;;;;;;:88;;33789:228;33611:3;;33583:445;;;;8719:9;:7;:9::i;:::-;8711:54;;;;;-1:-1:-1;;;8711:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;8711:54:0;;;;;;;;;;;;;;;42885:1;42871:11;:15;42863:63;;;;-1:-1:-1;;;42863:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42937:11;42951:23;:21;:23::i;:::-;42937:37;-1:-1:-1;43005:15:0;42985:17;43034:765;43057:3;43053:1;:7;43034:765;;;43082:21;43106:11;;;:8;:11;;;;;;;;:16;;;;;;;;43153:17;;;;43141:29;;43137:651;;;43208:12;;;;:7;:12;;;;;:21;;;43194:35;;43191:248;;;43254:17;43296:12;;;:7;:12;;;;;:21;;;43274:17;;;;:44;;;:21;:44;:::i;:::-;43254:64;-1:-1:-1;43378:9:0;43349:26;43254:64;43363:11;43349:26;:13;:26;:::i;:::-;:38;43341:78;;;;;-1:-1:-1;;;43341:78:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;43191:248;;43495:17;;;;43475;;43495:32;;43517:9;43495:32;:21;:32;:::i;:::-;43475:52;;43546:16;43565:30;43579:4;:15;;;43565:9;:13;;:30;;;;:::i;:::-;43546:49;-1:-1:-1;43632:25:0;43546:49;43645:11;43632:25;:12;:25;:::i;:::-;43614:15;;;:43;43676:19;;;:31;;;43746:26;43698:9;43760:11;43746:26;:13;:26;:::i;:::-;43726:17;;;:46;-1:-1:-1;;43137:651:0;-1:-1:-1;43062:3:0;;43034:765;;;-1:-1:-1;;;43809:12:0;;;;-1:-1:-1;;43809:7:0;:12;;-1:-1:-1;;43809:12:0;;;;:21;;:35;42691:1161::o;35738:556::-;35825:7;35806:3;34113:7;;34107:3;:13;34099:39;;;;;-1:-1:-1;;;34099:39:0;;;;;;;;;;;;-1:-1:-1;;;34099:39:0;;;;;;;;;;;;;;;35849:12;;;;:7;:12;;;;;:19;;;35845:103;;35897:13;;;;:8;:13;;;;;;;;:18;;;;;;;;:39;;;;-1:-1:-1;35890:46:0;;35845:103;36251:12;;;;:7;:12;;;;;;;;:19;;;36162:13;;;:8;:13;;;;;:18;;;;;;;;;:29;;;;36101:33;;;;;35978:308;;36040:231;;36251:19;;36040:184;;36219:4;;36040:152;;36162:29;36040:152;;:34;36162:13;36251:12;36040:24;:34::i;:95::-;:121;:152;:121;:152;:::i;:231::-;35978:13;;;;:8;:13;;;;;;;;:18;;;;;;;;:39;;;;:308;:43;:308;:::i;32777:65::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;43864:116::-;8719:9;:7;:9::i;:::-;8711:54;;;;;-1:-1:-1;;;8711:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;8711:54:0;;;;;;;;;;;;;;;43923:6;:16;;;;;-1:-1:-1;;43923:16:0;;;;;;;;43955:17;;;;;;;;;;;;;;;;43864:116;:::o;35116:115::-;35175:7;35202:21;:11;35217:5;35202:21;:14;:21;:::i;9613:109::-;8719:9;:7;:9::i;:::-;8711:54;;;;;-1:-1:-1;;;8711:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;8711:54:0;;;;;;;;;;;;;;;9686:28;9705:8;9686:18;:28::i;:::-;9613:109;:::o;31893:18::-;;;;;;:::o;39535:2335::-;39623:9;;39616:4;:16;39613:64;;;39656:9;;39649:16;;39613:64;39714:12;;;;:7;:12;;;;;:24;;;:36;;39743:6;39714:36;:28;:36;:::i;:::-;39687:12;;;;:7;:12;;;;;;;;:24;;:63;;;;39794:4;:9;;;;;39804:10;39794:21;;;;;:30;:42;;39829:6;39794:42;:34;:42;:::i;:::-;39761:9;;;;:4;:9;;;;;;;;39771:10;39761:21;;;;;;;;;:75;;;39918:12;;;:7;:12;;;;;:19;;;39963:21;;;;;;;:29;;;;;39869:15;;39918:19;39951:41;;39948:1822;;;40041:9;;;;:4;:9;;;;;;;;40051:10;40041:21;;;;;;;:28;;;40024:46;;:12;;:46;:16;:46;:::i;:::-;40137:9;;;;:4;:9;;;;;;;;40147:10;40137:21;;;;;;;:32;;;40110:12;;;:7;:12;;;;;;:22;;;40009:61;;-1:-1:-1;40110:70:0;;40175:4;;40110:60;;:22;:60;:26;:60;:::i;:70::-;40085:12;;;;:7;:12;;;;;;;;:22;;:95;;;;40195:4;:9;;;;;40205:10;40195:21;;;;;:32;;:39;;;40281:19;:9;40230:4;40281:19;:13;:19;:::i;:::-;40249:9;;;;:4;:9;;;;;;;;40259:10;40249:21;;;;;;;:29;;;:51;;;;40315:30;;;:42;;;40403:30;:40;;40438:4;40403:34;:40::i;:::-;40372:9;;;;:4;:9;;;;;;;;40382:10;40372:21;;;;;;;:28;;:71;;;40473:46;;:12;;:16;:46::i;:::-;40534:12;;;;:7;:12;;;;;:19;;:34;;;40458:61;-1:-1:-1;39948:1822:0;;;40633:9;;;;:4;:9;;;;;;;;40643:10;40633:21;;;;;;;:28;;;40616:46;;:12;;:46;:16;:46;:::i;:::-;40677:16;40710:9;;;:4;:9;;;;;;;;40720:10;40710:21;;;;;;;:30;;;40601:61;;-1:-1:-1;40677:16:0;40696:45;;:9;;:45;:13;:45;:::i;:::-;40756:19;40809:9;;;:4;:9;;;;;;;;40819:10;40809:21;;;;;;;:32;;;40677:64;;-1:-1:-1;40756:19:0;40797:44;;40794:144;;40876:9;;;;:4;:9;;;;;;;;40886:10;40876:21;;;;;;;:32;;;:46;;40913:8;40876:46;:36;:46;:::i;:::-;40862:60;;40794:144;41004:9;;;;:4;:9;;;;;;;;41014:10;41004:21;;;;;;;:32;;;40977:12;;;:7;:12;;;;;;:22;;;:60;;;:26;:60;:::i;:::-;40952:12;;;;:7;:12;;;;;:22;;:85;41089:21;:11;41105:4;41089:21;:15;:21;:::i;:::-;41054:9;;;;:4;:9;;;;;;;;41064:10;41054:21;;;;;;;:32;;:56;;;41163:9;;-1:-1:-1;41125:128:0;;;41228:9;;41193;;;;:4;:9;;;;;;;;41203:10;41193:21;;;;;;;:32;;:44;41125:128;41313:9;;;;:4;:9;;;;;;;;41323:10;41313:21;;;;;;;:32;;;:47;;41350:9;41313:47;:36;:47;:::i;:::-;41281:9;;;;:4;:9;;;;;;;;41291:10;41281:21;;;;;;;:29;;;:79;;;;41375:30;;;:42;;;-1:-1:-1;41498:32:0;;;41463:30;;:68;;:34;:68::i;:::-;41432:9;;;;:4;:9;;;;;;;;41442:10;41432:21;;;;;;;:28;;;:99;;;;41600:32;;;;;41573:12;;;:7;:12;;;;;;:22;;;:60;;;:26;:60;:::i;:::-;41548:12;;;;:7;:12;;;;;;;;:22;;:85;;;;41680:4;:9;;;;;41690:10;41680:21;;;;;:28;;;41663:46;;:12;;:46;:16;:46;:::i;:::-;41724:12;;;;:7;:12;;;;;:19;;:34;;;41648:61;-1:-1:-1;;;39948:1822:0;41790:12;;;;:7;:12;;;;;:20;:72;;-1:-1:-1;;;;;41790:20:0;41828:10;41848:4;41855:6;41790:72;:37;:72;:::i;:::-;39535:2335;;;;;:::o;7255:98::-;7335:10;7255:98;:::o;4110:132::-;4168:7;4195:39;4199:1;4202;4195:39;;;;;;;;;;;;;;;;;:3;:39::i;:::-;4188:46;4110:132;-1:-1:-1;;;4110:132:0:o;2255:136::-;2313:7;2340:43;2344:1;2347;2340:43;;;;;;;;;;;;;;;;;:3;:43::i;3171:471::-;3229:7;3474:6;3470:47;;-1:-1:-1;3504:1:0;3497:8;;3470:47;3541:5;;;3545:1;3541;:5;:1;3565:5;;;;;:10;3557:56;;;;-1:-1:-1;;;3557:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1799:181;1857:7;1889:5;;;1913:6;;;;1905:46;;;;;-1:-1:-1;;;1905:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;16980:204;17107:68;;;-1:-1:-1;;;;;17107:68:0;;;;;;;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;17107:68:0;;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;17081:95:0;;17100:5;;17081:18;:95::i;:::-;16980:204;;;;:::o;27640:158::-;27720:4;27744:46;27754:3;-1:-1:-1;;;;;27774:14:0;;27744:9;:46::i;27086:143::-;27156:4;27180:41;27185:3;-1:-1:-1;;;;;27205:14:0;;27180:4;:41::i;38061:437::-;38127:14;38144:28;38151:3;38156;38161:10;38144:6;:28::i;:::-;38127:45;-1:-1:-1;38187:10:0;;38183:308;;38255:1;38214:13;;;:8;:13;;;;;;;;:18;;;;;;;;38233:10;38214:30;;;;;;;:38;;:42;;;38303:13;;;:8;:13;;;;;:18;;;;;;;;:29;:41;;38337:6;38303:41;:33;:41;:::i;:::-;38271:13;;;;:8;:13;;;;;;;;:18;;;;;;;;:73;38359:60;38400:10;38412:6;38366:19;38280:3;38366:14;:19::i;:::-;-1:-1:-1;;;;;38359:40:0;;:60;;:40;:60;:::i;:::-;38439:40;;;;;;;;;;;;;;;;;;;;38450:10;;38439:40;;;;;;;;;;38183:308;38061:437;;;:::o;41878:789::-;41946:20;41969:12;;;:7;:12;;;;;;;;:19;;;;;42031:4;:9;;;;;42041:10;42031:21;;;;;;;:28;;;;42014:46;;41969:19;;42014:46;:16;:46;:::i;:::-;42100:12;;;;:7;:12;;;;;:24;;;41999:61;;-1:-1:-1;42100:36:0;;42129:6;42100:36;:28;:36;:::i;:::-;42073:12;;;;:7;:12;;;;;;;;:24;;:63;;;;42180:4;:9;;;;;42190:10;42180:21;;;;;:30;:42;;42215:6;42180:42;:34;:42;:::i;:::-;42147:9;;;;:4;:9;;;;;;;;42157:10;42147:21;;;;;;;:75;;;42255:15;42281:30;;;:42;;;42402:32;;;;;42255:15;;42367:68;;:34;:68::i;:::-;42336:9;;;;:4;:9;;;;;;;;42346:10;42336:21;;;;;;;:28;;:99;;;42461:46;;:12;;:16;:46::i;:::-;42518:12;;;;:7;:12;;;;;:19;;:34;;;42446:61;-1:-1:-1;42568:10:0;;42565:95;;42595:12;;;;:7;:12;;;;;:20;:53;;-1:-1:-1;;;;;42595:20:0;42629:10;42641:6;42595:53;:33;:53;:::i;27884:117::-;27947:7;27974:19;27982:3;27974:7;:19::i;460:106::-;518:7;549:1;545;:5;:13;;557:1;545:13;;;-1:-1:-1;553:1:0;;460:106;-1:-1:-1;460:106:0:o;28345:149::-;28419:7;28462:22;28466:3;28478:5;28462:3;:22::i;9828:229::-;-1:-1:-1;;;;;9902:22:0;;9894:73;;;;-1:-1:-1;;;9894:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10004:6;;;9983:38;;-1:-1:-1;;;;;9983:38:0;;;;10004:6;;;9983:38;;;10032:6;:17;;-1:-1:-1;;;;;;10032:17:0;-1:-1:-1;;;;;10032:17:0;;;;;;;;;;9828:229::o;4772:345::-;4858:7;4960:12;4953:5;4945:28;;;;-1:-1:-1;;;4945:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;4945:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4984:9;5000:1;4996;:5;;;;;;;4772:345;-1:-1:-1;;;;;4772:345:0:o;2728:192::-;2814:7;2850:12;2842:6;;;;2834:29;;;;-1:-1:-1;;;2834:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;2834:29:0;-1:-1:-1;;;2886:5:0;;;2728:192::o;18835:1114::-;19439:27;19447:5;-1:-1:-1;;;;;19439:25:0;;:27::i;:::-;19431:71;;;;;-1:-1:-1;;;19431:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;19576:12;19590:23;19625:5;-1:-1:-1;;;;;19617:19:0;19637:4;19617:25;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;19617:25:0;;;;;;;;;;;;;;;;;;;;;;;;14:1:-1;21;16:31;;;;75:4;69:11;64:16;;144:4;140:9;133:4;115:16;111:27;107:43;104:1;100:51;94:4;87:65;169:16;166:1;159:27;225:16;222:1;215:4;212:1;208:12;193:49;7:242;;16:31;36:4;31:9;;7:242;;19575:67:0;;;;19661:7;19653:52;;;;;-1:-1:-1;;;19653:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19722:17;;:21;19718:224;;19864:10;19853:30;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;19853:30:0;19845:85;;;;-1:-1:-1;;;19845:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24370:129;24443:4;24467:19;;;:12;;;;;:19;;;;;;:24;;;24370:129::o;22150:414::-;22213:4;22235:21;22245:3;22250:5;22235:9;:21::i;:::-;22230:327;;-1:-1:-1;27:10;;39:1;23:18;;;45:23;;22273:11:0;:23;;;;;;;;;;;;;22456:18;;22434:19;;;:12;;;:19;;;;;;:40;;;;22489:11;;22230:327;-1:-1:-1;22540:5:0;22533:12;;16796:176;16905:58;;;-1:-1:-1;;;;;16905:58:0;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;16905:58:0;;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;16879:85:0;;16898:5;;16879:18;:85::i;24585:109::-;24668:18;;24585:109::o;25038:204::-;25133:18;;25105:7;;25133:26;-1:-1:-1;25125:73:0;;;;-1:-1:-1;;;25125:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25216:3;:11;;25228:5;25216:18;;;;;;;;;;;;;;;;25209:25;;25038:204;;;;:::o;13633:810::-;13693:4;14352:20;;14195:66;14392:15;;;;;:42;;-1:-1:-1;14411:23:0;;;14384:51;-1:-1:-1;;13633:810:0:o

Swarm Source

bzzr://b859796ee3c72a7864fb6765d408040cb911769bd9e84f56a65fd8dddfbfa5c0
Block Transaction Gas Used Reward
Age Block Fee Address Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading