Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
•  contract ERC20 is Context, IERC20
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
•    - function increaseAllowance(address sp ...
•    - function decreaseAllowance(address sp ...
•    - function _transfer(address sender, ad ...
•    - function _mint(address account, uint2 ...
•    - function _burn(address account, uint2 ...
•    - function _approve(address owner, addr ...
•    - function _setupDecimals(uint8 decimal ...
•    - function _beforeTokenTransfer(address ...
• interface IStaking
•    - function unstake(address staker, uint ...
•    - function totalStakedFor(address addr)
•    - function totalStaked()
•    - function token()
•    - function supportsHistory()
• interface IStake
•    - function stake(
•    - function stakeFor(
•  contract TokenPool is Ownable
•    - function balance()
•    - function setRescuable(bool rescuable)
•    - function transfer(address to, uint256 ...
•    - function rescueFunds(
•  contract TokenGeyserWithoutNFT is ... *
•    - function getEarnings(address user)
•    - function rescueRewards(address user)
•    - function getStakingToken()
•    - function getDistributionToken()
•    - function stake(
•    - function stakeFor(
•    - function _stakeFor(
•    - function unstake(
•    - function unstakeQuery(address staker, ...
•    - function _unstake(address user, uint2 ...
•    - function computeNewReward(
•    - function totalStakedFor(address addr)
•    - function totalStaked()
•    - function token()
•    - function updateAccounting(address use ...
•    - function totalLocked()
•    - function totalUnlocked()
•    - function unlockScheduleCount()
•    - function lockTokens(uint256 amount, u ...
•    - function unlockTokens()
•    - function _unlockTokens()
•    - function unlockScheduleShares(uint256 ...
•    - function rescueFundsFromStakingPool(
•    - function supportsHistory()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-02-14
*/

pragma solidity ^0.6.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;
    }
}


/*
 * @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.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

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


/**
 * @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.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * 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.
 */
abstract 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 {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @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(_owner == _msgSender(), "Ownable: caller is not the 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 virtual 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 virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// SPDX-License-Identifier: MIT
/**
 * @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
/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC20 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20 {
    using SafeMath for uint256;

    mapping (address => uint256) private _balances;

    mapping (address => mapping (address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;
    uint8 private _decimals;

    /**
     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
     * a default value of 18.
     *
     * To select a different value for {decimals}, use {_setupDecimals}.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor (string memory name_, string memory symbol_) public {
        _name = name_;
        _symbol = symbol_;
        _decimals = 18;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5,05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is
     * called.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view returns (uint8) {
        return _decimals;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(address sender, address recipient, uint256 amount) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Sets {decimals} to a value other than the default one of 18.
     *
     * WARNING: This function should only be called from the constructor. Most
     * applications that interact with token contracts will not expect
     * {decimals} to ever change, and may work incorrectly if it does.
     */
    function _setupDecimals(uint8 decimals_) internal {
        _decimals = decimals_;
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be to transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}

// SPDX-License-Identifier: MIT
/**
 * @title Staking interface, as defined by EIP-900.
 * @dev https://github.com/ethereum/EIPs/blob/master/EIPS/eip-900.md
 */
interface IStaking {
    event Staked(
        address indexed user,
        uint256 amount,
        uint256 total,
        bytes data
    );
    event Unstaked(
        address indexed user,
        uint256 amount,
        uint256 total,
        bytes data
    );

    function unstake(address staker, uint256 amount, bytes calldata data) external;

    function totalStakedFor(address addr) external view returns (uint256);

    function totalStaked() external view returns (uint256);

    function token() external view returns (address);

    function supportsHistory() external pure returns (bool);
}

// SPDX-License-Identifier: MIT
/**
 * @title Staking interface, as defined by EIP-900.
 * @dev https://github.com/ethereum/EIPs/blob/master/EIPS/eip-900.md
 */
interface IStake {
    function stake(
        address staker,
        uint256 amount,
        bytes calldata data
    ) external;

    function stakeFor(
        address staker,
        address user,
        uint256 amount,
        bytes calldata data
    ) external;
}

// SPDX-License-Identifier: MIT
/**
 * @title A simple holder of tokens.
 * This is a simple contract to hold tokens. It's useful in the case where a separate contract
 * needs to hold multiple distinct pools of the same token.
 */
contract TokenPool is Ownable {
    IERC20 public token;
    bool private _isTokenRescuable;

    constructor(IERC20 _token) public {
        token = _token;
        _isTokenRescuable = false;
    }

    function balance() public view returns (uint256) {
        return token.balanceOf(address(this));
    }

    function setRescuable(bool rescuable) public onlyOwner {
        _isTokenRescuable = rescuable;
    }

    function transfer(address to, uint256 value)
        external
        onlyOwner
        returns (bool)
    {
        return token.transfer(to, value);
    }

    function rescueFunds(
        address tokenToRescue,
        address to,
        uint256 amount
    ) external onlyOwner returns (bool) {
        if (!_isTokenRescuable) {
            require(
                address(token) != tokenToRescue,
                "TokenPool: Cannot claim token held by the contract"
            );
        }

        return IERC20(tokenToRescue).transfer(to, amount);
    }
}

// SPDX-License-Identifier: MIT
/**
 * @title Non Nft Token Geyser
 * @dev A smart-contract based mechanism to distribute tokens over time, inspired loosely by
 *      Compound and Uniswap.
 *
 *      Distribution tokens are added to a locked pool in the contract and become unlocked over time
 *      according to a once-configurable unlock schedule. Once unlocked, they are available to be
 *      claimed by users.
 *
 *      A user may deposit tokens to accrue ownership share over the unlocked pool. This owner share
 *      is a function of the number of tokens deposited as well as the length of time deposited.
 *      Specifically, a user's share of the currently-unlocked pool equals their "deposit-seconds"
 *      divided by the global "deposit-seconds". This aligns the new token distribution with long
 *      term supporters of the project, addressing one of the major drawbacks of simple airdrops.
 *
 *      More background and motivation available at:
 *      https://github.com/ampleforth/RFCs/blob/master/RFCs/rfc-1.md
 */
contract TokenGeyserWithoutNFT is IStaking, IStake, Ownable {
    using SafeMath for uint256;

    event Staked(
        address indexed user,
        uint256 amount,
        uint256 total,
        bytes data
    );
    event Unstaked(
        address indexed user,
        uint256 amount,
        uint256 total,
        bytes data
    );
    event TokensClaimed(address indexed user, uint256 amount);
    event TokensLocked(uint256 amount, uint256 durationSec, uint256 total);
    // amount: Unlocked tokens, total: Total locked tokens
    event TokensUnlocked(uint256 amount, uint256 total);

    TokenPool private _stakingPool;
    TokenPool private _unlockedPool;
    TokenPool private _lockedPool;

    //
    // Time-bonus params
    //
    uint256 public bonusDecimals = 2;
    uint256 public startBonus = 0;
    uint256 public bonusPeriodSec = 0;

    //
    // Global accounting state
    //
    uint256 public totalLockedShares = 0;
    uint256 public totalStakingShares = 0;
    uint256 private _totalStakingShareSeconds = 0;
    uint256 private _lastAccountingTimestampSec = now;
    uint256 private _maxUnlockSchedules = 0;
    uint256 private _initialSharesPerToken = 0;

    //
    // User accounting state
    //
    // Represents a single stake for a user. A user may have multiple.
    struct Stake {
        uint256 stakingShares;
        uint256 timestampSec;
    }

    // Caches aggregated values from the User->Stake[] map to save computation.
    // If lastAccountingTimestampSec is 0, there's no entry for that user.
    struct UserTotals {
        uint256 stakingShares;
        uint256 stakingShareSeconds;
        uint256 lastAccountingTimestampSec;
    }

    // Aggregated staking values per user
    mapping(address => UserTotals) private _userTotals;

    // The collection of stakes for each user. Ordered by timestamp, earliest to latest.
    mapping(address => Stake[]) private _userStakes;

    mapping(address => uint256) userEarnings;

    //
    // Locked/Unlocked Accounting state
    //
    struct UnlockSchedule {
        uint256 initialLockedShares;
        uint256 unlockedShares;
        uint256 lastUnlockTimestampSec;
        uint256 endAtSec;
        uint256 durationSec;
    }

    UnlockSchedule[] public unlockSchedules;

    address public geyserManager;

    /**
     * @param stakingToken The token users deposit as stake.
     * @param distributionToken The token users receive as they unstake.
     * @param maxUnlockSchedules Max number of unlock stages, to guard against hitting gas limit.
     * @param startBonus_ Starting time bonus
     *                    e.g. 25% means user gets 25% of max distribution tokens.
     * @param bonusPeriodSec_ Length of time for bonus to increase linearly to max.
     * @param initialSharesPerToken Number of shares to mint per staking token on first stake.
     * @param bonusDecimals_ The number of decimals for shares
     */
    constructor(
        IERC20 stakingToken,
        IERC20 distributionToken,
        uint256 maxUnlockSchedules,
        uint256 startBonus_,
        uint256 bonusPeriodSec_,
        uint256 initialSharesPerToken,
        uint256 bonusDecimals_,
        address managerAddress
    ) public {
        // The start bonus must be some fraction of the max. (i.e. <= 100%)
        require(
            startBonus_ <= 10**bonusDecimals_,
            "TokenGeyser: start bonus too high"
        );
        // If no period is desired, instead set startBonus = 100%
        // and bonusPeriod to a small value like 1sec.
        require(bonusPeriodSec_ != 0, "TokenGeyser: bonus period is zero");
        require(
            initialSharesPerToken > 0,
            "TokenGeyser: initialSharesPerToken is zero"
        );

        require(bonusDecimals_ > 0, "TokenGeyser: bonusDecimals_ is zero");

        _stakingPool = new TokenPool(stakingToken);
        _unlockedPool = new TokenPool(distributionToken);
        _lockedPool = new TokenPool(distributionToken);
        _unlockedPool.setRescuable(true);

        geyserManager = managerAddress;
        startBonus = startBonus_;
        bonusDecimals = bonusDecimals_;
        bonusPeriodSec = bonusPeriodSec_;
        _maxUnlockSchedules = maxUnlockSchedules;
        _initialSharesPerToken = initialSharesPerToken;
    }

    /**
     * @return Total earnings for a user
    */
    function getEarnings(address user) public view returns (uint256) {
        return userEarnings[user];
    }

    /**
     * @dev Rescue rewards
     */
    function rescueRewards(address user) external onlyOwner {
        require(totalUnlocked() > 0, "TokenGeyser: Nothing to rescue");
        require(
            _unlockedPool.transfer(user, _unlockedPool.balance()),
            "TokenGeyser: rescue rewards from rewards pool failed"
        );
    }

    /**
     * @return The token users deposit as stake.
     */
    function getStakingToken() public view returns (IERC20) {
        return _stakingPool.token();
    }

    /**
     * @return The token users receive as they unstake.
     */
    function getDistributionToken() public view returns (IERC20) {
        assert(_unlockedPool.token() == _lockedPool.token());
        return _unlockedPool.token();
    }

    event log(string s);
    event log(uint256 s);
    event log(address s);

    /**
     * @dev Transfers amount of deposit tokens from the user.
     * @param amount Number of deposit tokens to stake.
     * @param data Not used.
     */
    function stake(
        address staker,
        uint256 amount,
        bytes calldata data
    ) external override {
        require(
            geyserManager == msg.sender,
            "This method can be called by the geyser manager only"
        );
        _stakeFor(staker, staker, amount);
    }

    /**
     * @dev Transfers amount of deposit tokens from the caller on behalf of user.
     * @param user User address who gains credit for this stake operation.
     * @param amount Number of deposit tokens to stake.
     * @param data Not used.
     */
    function stakeFor(
        address staker,
        address user,
        uint256 amount,
        bytes calldata data
    ) external override onlyOwner {
        require(
            geyserManager == msg.sender,
            "This method can be called by the geyser manager only"
        );
        _stakeFor(staker, user, amount);
    }

    /**
     * @dev Private implementation of staking methods.
     * @param staker User address who deposits tokens to stake.
     * @param beneficiary User address who gains credit for this stake operation.
     * @param amount Number of deposit tokens to stake.
     */
    function _stakeFor(
        address staker,
        address beneficiary,
        uint256 amount
    ) private {
        require(amount > 0, "TokenGeyser: stake amount is zero");
        require(
            beneficiary != address(0),
            "TokenGeyser: beneficiary is zero address"
        );
        require(
            totalStakingShares == 0 || totalStaked() > 0,
            "TokenGeyser: Invalid state. Staking shares exist, but no staking tokens do"
        );


        uint256 mintedStakingShares =
            (totalStakingShares > 0)
                ? totalStakingShares.mul(amount).div(totalStaked())
                : amount.mul(_initialSharesPerToken);

        require(
            mintedStakingShares > 0,
            "TokenGeyser: Stake amount is too small"
        );

        updateAccounting(beneficiary);

        // 1. User Accounting
        UserTotals storage totals = _userTotals[beneficiary];
        totals.stakingShares = totals.stakingShares.add(mintedStakingShares);
        totals.lastAccountingTimestampSec = now;

        Stake memory newStake = Stake(mintedStakingShares, now);
        _userStakes[beneficiary].push(newStake);

        // 2. Global Accounting
        totalStakingShares = totalStakingShares.add(mintedStakingShares);
        // Already set in updateAccounting()
        // _lastAccountingTimestampSec = now;

        // interactions
        require(
            _stakingPool.token().transferFrom(
                staker,
                address(_stakingPool),
                amount
            ),
            "TokenGeyser: transfer into staking pool failed"
        );

        emit Staked(beneficiary, amount, totalStakedFor(beneficiary), "");
    }

    /**
     * @dev Unstakes a certain amount of previously deposited tokens. User also receives their
     * alotted number of distribution tokens.
     * @param amount Number of deposit tokens to unstake / withdraw.
     * @param data Not used.
     */
    function unstake(
        address staker,
        uint256 amount,
        bytes calldata data
    ) external override {
        require(
            geyserManager == msg.sender,
            "This method can be called by the geyser manager only"
        );
        _unstake(staker, amount);
    }

    /**
     * @param amount Number of deposit tokens to unstake / withdraw.
     * @return The total number of distribution tokens that would be rewarded.
     */
    function unstakeQuery(address staker, uint256 amount)
        public
        returns (uint256)
    {
        require(
            geyserManager == msg.sender,
            "This method can be called by the geyser manager only"
        );
        return _unstake(staker, amount);
    }

    /**
     * @dev Unstakes a certain amount of previously deposited tokens. User also receives their
     * alotted number of distribution tokens.
     * @param amount Number of deposit tokens to unstake / withdraw.
     * @return The total number of distribution tokens rewarded.
     */
    function _unstake(address user, uint256 amount) private returns (uint256) {
        updateAccounting(user);

        uint256 stakingSharesToBurn =
            totalStakingShares.mul(amount).div(totalStaked());

        require(
            stakingSharesToBurn > 0,
            "TokenGeyser: Unable to unstake amount this small"
        );

        // 1. User Accounting
        UserTotals storage totals = _userTotals[user];
        Stake[] storage accountStakes = _userStakes[user];

        // Redeem from most recent stake and go backwards in time.
        uint256 stakingShareSecondsToBurn = 0;
        uint256 sharesLeftToBurn = stakingSharesToBurn;
        uint256 rewardAmount = 0;
        while (sharesLeftToBurn > 0) {
            Stake storage lastStake = accountStakes[accountStakes.length - 1];
            uint256 stakeTimeSec = now.sub(lastStake.timestampSec);
            uint256 newStakingShareSecondsToBurn = 0;

            if (lastStake.stakingShares <= sharesLeftToBurn) {
                newStakingShareSecondsToBurn = lastStake.stakingShares.mul(
                    stakeTimeSec
                );
                rewardAmount = computeNewReward(
                    rewardAmount,
                    newStakingShareSecondsToBurn,
                    stakeTimeSec
                );

                stakingShareSecondsToBurn = stakingShareSecondsToBurn.add(
                    newStakingShareSecondsToBurn
                );
                sharesLeftToBurn = sharesLeftToBurn.sub(
                    lastStake.stakingShares
                );
                accountStakes.pop();
            } else {
                newStakingShareSecondsToBurn = sharesLeftToBurn.mul(
                    stakeTimeSec
                );
                rewardAmount = computeNewReward(
                    rewardAmount,
                    newStakingShareSecondsToBurn,
                    stakeTimeSec
                );
                stakingShareSecondsToBurn = stakingShareSecondsToBurn.add(
                    newStakingShareSecondsToBurn
                );
                lastStake.stakingShares = lastStake.stakingShares.sub(
                    sharesLeftToBurn
                );
                sharesLeftToBurn = 0;
            }
        }
        totals.stakingShareSeconds = totals.stakingShareSeconds.sub(
            stakingShareSecondsToBurn
        );
        totals.stakingShares = totals.stakingShares.sub(stakingSharesToBurn);
        // Already set in updateAccounting
        // totals.lastAccountingTimestampSec = now;

        // 2. Global Accounting
        _totalStakingShareSeconds = _totalStakingShareSeconds.sub(
            stakingShareSecondsToBurn
        );
        totalStakingShares = totalStakingShares.sub(stakingSharesToBurn);
        // Already set in updateAccountingF
        // _lastAccountingTimestampSec = now;

        // interactions
        require(
            _stakingPool.transfer(user, amount),
            "TokenGeyser: transfer out of staking pool failed"
        );

        //in case rescueRewards was called, there are no rewards to be transfered
        if (totalUnlocked() >= rewardAmount) {
            require(
                _unlockedPool.transfer(user, rewardAmount),
                "TokenGeyser: transfer out of unlocked pool failed"
            );
            emit TokensClaimed(user, rewardAmount);
            
             userEarnings[user] += rewardAmount;
        }

        emit Unstaked(user, amount, totalStakedFor(user), "");

        require(
            totalStakingShares == 0 || totalStaked() > 0,
            "TokenGeyser: Error unstaking. Staking shares exist, but no staking tokens do"
        );

        return rewardAmount;
    }

    /**
     * @dev Applies an additional time-bonus to a distribution amount. This is necessary to
     *      encourage long-term deposits instead of constant unstake/restakes.
     *      The bonus-multiplier is the result of a linear function that starts at startBonus and
     *      ends at 100% over bonusPeriodSec, then stays at 100% thereafter.
     * @param currentRewardTokens The current number of distribution tokens already alotted for this
     *                            unstake op. Any bonuses are already applied.
     * @param stakingShareSeconds The stakingShare-seconds that are being burned for new
     *                            distribution tokens.
     * @param stakeTimeSec Length of time for which the tokens were staked. Needed to calculate
     *                     the time-bonus.
     * @return Updated amount of distribution tokens to award, with any bonus included on the
     *         newly added tokens.
     */
    function computeNewReward(
        uint256 currentRewardTokens,
        uint256 stakingShareSeconds,
        uint256 stakeTimeSec
    ) private view returns (uint256) {
        uint256 newRewardTokens =
            totalUnlocked().mul(stakingShareSeconds).div(
                _totalStakingShareSeconds
            );

        if (stakeTimeSec >= bonusPeriodSec) {
            return currentRewardTokens.add(newRewardTokens);
        }

        uint256 oneHundredPct = 10**bonusDecimals;
        uint256 bonusedReward =
            startBonus
                .add(
                oneHundredPct.sub(startBonus).mul(stakeTimeSec).div(
                    bonusPeriodSec
                )
            )
                .mul(newRewardTokens)
                .div(oneHundredPct);

        return currentRewardTokens.add(bonusedReward);
    }

    /**
     * @param addr The user to look up staking information for.
     * @return The number of staking tokens deposited for addr.
     */
    function totalStakedFor(address addr)
        public
        view
        override
        returns (uint256)
    {
        return
            totalStakingShares > 0
                ? totalStaked().mul(_userTotals[addr].stakingShares).div(
                    totalStakingShares
                )
                : 0;
    }

    /**
     * @return The total number of deposit tokens staked globally, by all users.
     */
    function totalStaked() public view override returns (uint256) {
        return _stakingPool.balance();
    }

    /**
     * @dev Note that this application has a staking token as well as a distribution token, which
     * may be different. This function is required by EIP-900.
     * @return The deposit token used for staking.
     */
    function token() external view override returns (address) {
        return address(getStakingToken());
    }

    /**
     * @dev A globally callable function to update the accounting state of the system.
     *      Global state and state for the caller are updated.
     * @return [0] balance of the locked pool
     * @return [1] balance of the unlocked pool
     * @return [2] caller's staking share seconds
     * @return [3] global staking share seconds
     * @return [4] Rewards caller has accumulated, optimistically assumes max time-bonus.
     * @return [5] block timestamp
     */
    function updateAccounting(address user)
        public
        returns (
            uint256,
            uint256,
            uint256,
            uint256,
            uint256,
            uint256
        )
    {
        _unlockTokens();

        // Global accounting
        uint256 newStakingShareSeconds =
            now.sub(_lastAccountingTimestampSec).mul(totalStakingShares);
        _totalStakingShareSeconds = _totalStakingShareSeconds.add(
            newStakingShareSeconds
        );
        _lastAccountingTimestampSec = now;

        // User Accounting
        UserTotals storage totals = _userTotals[user];
        uint256 newUserStakingShareSeconds =
            now.sub(totals.lastAccountingTimestampSec).mul(
                totals.stakingShares
            );
        totals.stakingShareSeconds = totals.stakingShareSeconds.add(
            newUserStakingShareSeconds
        );
        totals.lastAccountingTimestampSec = now;

        uint256 totalUserRewards =
            (_totalStakingShareSeconds > 0)
                ? totalUnlocked().mul(totals.stakingShareSeconds).div(
                    _totalStakingShareSeconds
                )
                : 0;

        return (
            totalLocked(),
            totalUnlocked(),
            totals.stakingShareSeconds,
            _totalStakingShareSeconds,
            totalUserRewards,
            now
        );
    }

    /**
     * @return Total number of locked distribution tokens.
     */
    function totalLocked() public view returns (uint256) {
        return _lockedPool.balance();
    }

    /**
     * @return Total number of unlocked distribution tokens.
     */
    function totalUnlocked() public view returns (uint256) {
        return _unlockedPool.balance();
    }

    /**
     * @return Number of unlock schedules.
     */
    function unlockScheduleCount() public view returns (uint256) {
        return unlockSchedules.length;
    }

    /**
     * @dev This funcion allows the contract owner to add more locked distribution tokens, along
     *      with the associated "unlock schedule". These locked tokens immediately begin unlocking
     *      linearly over the duraction of durationSec timeframe.
     * @param amount Number of distribution tokens to lock. These are transferred from the caller.
     * @param durationSec Length of time to linear unlock the tokens.
     */
    function lockTokens(uint256 amount, uint256 durationSec)
        external
        onlyOwner
    {
        require(
            unlockSchedules.length < _maxUnlockSchedules,
            "TokenGeyser: reached maximum unlock schedules"
        );

        // Update lockedTokens amount before using it in computations after.
        updateAccounting(msg.sender);

        uint256 lockedTokens = totalLocked();
        uint256 mintedLockedShares =
            (lockedTokens > 0)
                ? totalLockedShares.mul(amount).div(lockedTokens)
                : amount.mul(_initialSharesPerToken);

        UnlockSchedule memory schedule;
        schedule.initialLockedShares = mintedLockedShares;
        schedule.lastUnlockTimestampSec = now;
        schedule.endAtSec = now.add(durationSec);
        schedule.durationSec = durationSec;
        unlockSchedules.push(schedule);

        totalLockedShares = totalLockedShares.add(mintedLockedShares);

        require(
            _lockedPool.token().transferFrom(
                msg.sender,
                address(_lockedPool),
                amount
            ),
            "TokenGeyser: transfer into locked pool failed"
        );
        emit TokensLocked(amount, durationSec, totalLocked());
    }

    /**
     * @dev Moves distribution tokens from the locked pool to the unlocked pool, according to the
     *      previously defined unlock schedules. Publicly callable.
     * @return Number of newly unlocked distribution tokens.
     */
    function unlockTokens() public onlyOwner returns (uint256) {
        _unlockTokens();
    }

    function _unlockTokens() private returns (uint256) {
        uint256 unlockedTokens = 0;
        uint256 lockedTokens = totalLocked();

        if (totalLockedShares == 0) {
            unlockedTokens = lockedTokens;
        } else {
            uint256 unlockedShares = 0;
            for (uint256 s = 0; s < unlockSchedules.length; s++) {
                unlockedShares = unlockedShares.add(unlockScheduleShares(s));
            }
            unlockedTokens = unlockedShares.mul(lockedTokens).div(
                totalLockedShares
            );
            totalLockedShares = totalLockedShares.sub(unlockedShares);
        }

        if (unlockedTokens > 0) {
            require(
                _lockedPool.transfer(address(_unlockedPool), unlockedTokens),
                "TokenGeyser: transfer out of locked pool failed"
            );
            emit TokensUnlocked(unlockedTokens, totalLocked());
        }

        return unlockedTokens;
    }

    /**
     * @dev Returns the number of unlockable shares from a given schedule. The returned value
     *      depends on the time since the last unlock. This function updates schedule accounting,
     *      but does not actually transfer any tokens.
     * @param s Index of the unlock schedule.
     * @return The number of unlocked shares.
     */
    function unlockScheduleShares(uint256 s) private returns (uint256) {
        UnlockSchedule storage schedule = unlockSchedules[s];

        if (schedule.unlockedShares >= schedule.initialLockedShares) {
            return 0;
        }

        uint256 sharesToUnlock = 0;
        // Special case to handle any leftover dust from integer division
        if (now >= schedule.endAtSec) {
            sharesToUnlock = (
                schedule.initialLockedShares.sub(schedule.unlockedShares)
            );
            schedule.lastUnlockTimestampSec = schedule.endAtSec;
        } else {
            sharesToUnlock = now
                .sub(schedule.lastUnlockTimestampSec)
                .mul(schedule.initialLockedShares)
                .div(schedule.durationSec);
            schedule.lastUnlockTimestampSec = now;
        }

        schedule.unlockedShares = schedule.unlockedShares.add(sharesToUnlock);
        return sharesToUnlock;
    }

    /**
     * @dev Lets the owner rescue funds air-dropped to the staking pool.
     * @param tokenToRescue Address of the token to be rescued.
     * @param to Address to which the rescued funds are to be sent.
     * @param amount Amount of tokens to be rescued.
     * @return Transfer success.
     */
    function rescueFundsFromStakingPool(
        address tokenToRescue,
        address to,
        uint256 amount
    ) public onlyOwner returns (bool) {
        return _stakingPool.rescueFunds(tokenToRescue, to, amount);
    }

    function supportsHistory() external pure override returns (bool) {
        return false;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IERC20","name":"stakingToken","type":"address"},{"internalType":"contract IERC20","name":"distributionToken","type":"address"},{"internalType":"uint256","name":"maxUnlockSchedules","type":"uint256"},{"internalType":"uint256","name":"startBonus_","type":"uint256"},{"internalType":"uint256","name":"bonusPeriodSec_","type":"uint256"},{"internalType":"uint256","name":"initialSharesPerToken","type":"uint256"},{"internalType":"uint256","name":"bonusDecimals_","type":"uint256"},{"internalType":"address","name":"managerAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"total","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"data","type":"bytes"}],"name":"Staked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokensClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"durationSec","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"total","type":"uint256"}],"name":"TokensLocked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"total","type":"uint256"}],"name":"TokensUnlocked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"total","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"data","type":"bytes"}],"name":"Unstaked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"s","type":"string"}],"name":"log","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"s","type":"uint256"}],"name":"log","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"s","type":"address"}],"name":"log","type":"event"},{"inputs":[],"name":"bonusDecimals","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bonusPeriodSec","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDistributionToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getEarnings","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getStakingToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"geyserManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"durationSec","type":"uint256"}],"name":"lockTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenToRescue","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"rescueFundsFromStakingPool","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"rescueRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"staker","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"staker","type":"address"},{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"stakeFor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startBonus","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"supportsHistory","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalLocked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalLockedShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalStaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"totalStakedFor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalStakingShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalUnlocked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unlockScheduleCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"unlockSchedules","outputs":[{"internalType":"uint256","name":"initialLockedShares","type":"uint256"},{"internalType":"uint256","name":"unlockedShares","type":"uint256"},{"internalType":"uint256","name":"lastUnlockTimestampSec","type":"uint256"},{"internalType":"uint256","name":"endAtSec","type":"uint256"},{"internalType":"uint256","name":"durationSec","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unlockTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"staker","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"unstake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"staker","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"unstakeQuery","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"updateAccounting","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"}]

0x608060405234801561001057600080fd5b50600436106101cf5760003560e01c8063812ae2c511610104578063b90817f2116100a2578063ee72b9d011610071578063ee72b9d014610569578063f2fde38b146105c2578063f968f493146105e8578063fc0c546a146105f0576101cf565b8063b90817f21461048a578063c4113b88146104b0578063c7ae200714610535578063d71115f01461053d576101cf565b806389158d8e116100de57806389158d8e1461044f5780638da5cb5b146104725780639f9106d11461047a578063a779d08014610482576101cf565b8063812ae2c514610437578063817b1cd21461043f57806381c39bec14610447576101cf565b80635a72bbef1161017157806370c6a17e1161014b57806370c6a17e1461038f578063715018a6146103975780637c6aa6f41461039f5780637cb446a8146103a7576101cf565b80635a72bbef146102f55780635c94bcb21461033f5780637033e4a614610387576101cf565b80633e12170f116101ad5780633e12170f146102385780633e1d0ae5146102bf5780634b341aed146102c757806356891412146102ed576101cf565b8063131b9c04146101d457806322c12b841461020c57806338b45fde14610230575b600080fd5b6101fa600480360360208110156101ea57600080fd5b50356001600160a01b03166105f8565b60408051918252519081900360200190f35b610214610617565b604080516001600160a01b039092168252519081900360200190f35b6101fa61078c565b6102bd6004803603606081101561024e57600080fd5b6001600160a01b038235169160208101359181019060608101604082013564010000000081111561027e57600080fd5b82018360208201111561029057600080fd5b803590602001918460018302840111640100000000831117156102b257600080fd5b509092509050610792565b005b6101fa6107ec565b6101fa600480360360208110156102dd57600080fd5b50356001600160a01b03166107f2565b6101fa61084f565b61032b6004803603606081101561030b57600080fd5b506001600160a01b03813581169160208101359091169060400135610894565b604080519115158252519081900360200190f35b61035c6004803603602081101561035557600080fd5b5035610982565b6040805195865260208601949094528484019290925260608401526080830152519081900360a00190f35b61032b6109c0565b6101fa6109c5565b6102bd6109cb565b6101fa610a6d565b6102bd600480360360808110156103bd57600080fd5b6001600160a01b038235811692602081013590911691604082013591908101906080810160608201356401000000008111156103f857600080fd5b82018360208201111561040a57600080fd5b8035906020019184600183028401116401000000008311171561042c57600080fd5b509092509050610a73565b610214610b26565b6101fa610b35565b6101fa610b7a565b6102bd6004803603604081101561046557600080fd5b5080359060200135610b80565b610214610f10565b610214610f1f565b6101fa610f64565b6102bd600480360360208110156104a057600080fd5b50356001600160a01b0316610fa9565b6102bd600480360360608110156104c657600080fd5b6001600160a01b03823516916020810135918101906060810160408201356401000000008111156104f657600080fd5b82018360208201111561050857600080fd5b8035906020019184600183028401116401000000008311171561052a57600080fd5b509092509050611190565b6101fa6111e3565b6101fa6004803603604081101561055357600080fd5b506001600160a01b0381351690602001356111e9565b61058f6004803603602081101561057f57600080fd5b50356001600160a01b031661123f565b604080519687526020870195909552858501939093526060850191909152608084015260a0830152519081900360c00190f35b6102bd600480360360208110156105d857600080fd5b50356001600160a01b031661133d565b6101fa611435565b61021461149b565b6001600160a01b0381166000908152600f60205260409020545b919050565b60035460408051637e062a3560e11b815290516000926001600160a01b03169163fc0c546a916004808301926020929190829003018186803b15801561065c57600080fd5b505afa158015610670573d6000803e3d6000fd5b505050506040513d602081101561068657600080fd5b505160025460408051637e062a3560e11b815290516001600160a01b03938416939092169163fc0c546a91600480820192602092909190829003018186803b1580156106d157600080fd5b505afa1580156106e5573d6000803e3d6000fd5b505050506040513d60208110156106fb57600080fd5b50516001600160a01b03161461070d57fe5b600260009054906101000a90046001600160a01b03166001600160a01b031663fc0c546a6040518163ffffffff1660e01b815260040160206040518083038186803b15801561075b57600080fd5b505afa15801561076f573d6000803e3d6000fd5b505050506040513d602081101561078557600080fd5b5051905090565b60055481565b6011546001600160a01b031633146107db5760405162461bcd60e51b81526004018080602001828103825260348152602001806123a46034913960400191505060405180910390fd5b6107e68485856114aa565b50505050565b60045481565b60008060085411610804576000610849565b6008546001600160a01b0383166000908152600d6020526040902054610849919061083d90610831610b35565b9063ffffffff61184616565b9063ffffffff61189f16565b92915050565b600354604080516316d3df1560e31b815290516000926001600160a01b03169163b69ef8a8916004808301926020929190829003018186803b15801561075b57600080fd5b600061089e6118e1565b6000546001600160a01b039081169116146108ee576040805162461bcd60e51b815260206004820181905260248201526000805160206124ba833981519152604482015290519081900360640190fd5b60015460408051631b32b81560e21b81526001600160a01b03878116600483015286811660248301526044820186905291519190921691636ccae0549160648083019260209291908290030181600087803b15801561094c57600080fd5b505af1158015610960573d6000803e3d6000fd5b505050506040513d602081101561097657600080fd5b505190505b9392505050565b6010818154811061098f57fe5b6000918252602090912060059091020180546001820154600283015460038401546004909401549294509092909185565b600090565b60085481565b6109d36118e1565b6000546001600160a01b03908116911614610a23576040805162461bcd60e51b815260206004820181905260248201526000805160206124ba833981519152604482015290519081900360640190fd5b600080546040516001600160a01b03909116907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908390a3600080546001600160a01b0319169055565b60065481565b610a7b6118e1565b6000546001600160a01b03908116911614610acb576040805162461bcd60e51b815260206004820181905260248201526000805160206124ba833981519152604482015290519081900360640190fd5b6011546001600160a01b03163314610b145760405162461bcd60e51b81526004018080602001828103825260348152602001806123a46034913960400191505060405180910390fd5b610b1f8585856114aa565b5050505050565b6011546001600160a01b031681565b600154604080516316d3df1560e31b815290516000926001600160a01b03169163b69ef8a8916004808301926020929190829003018186803b15801561075b57600080fd5b60075481565b610b886118e1565b6000546001600160a01b03908116911614610bd8576040805162461bcd60e51b815260206004820181905260248201526000805160206124ba833981519152604482015290519081900360640190fd5b600b5460105410610c1a5760405162461bcd60e51b815260040180806020018281038252602d815260200180612524602d913960400191505060405180910390fd5b610c233361123f565b5050505050506000610c3361084f565b90506000808211610c5757600c54610c5290859063ffffffff61184616565b610c70565b610c708261083d8660075461184690919063ffffffff16565b9050610c7a61221b565b8181524260408201819052610c95908563ffffffff6118e516565b60608201908152608082018581526010805460018101825560009190915283517f1b6847dc741a1b0cd08d278845f9d819d87b734759afb55fe2de5cb82a9ae67260059092029182015560208401517f1b6847dc741a1b0cd08d278845f9d819d87b734759afb55fe2de5cb82a9ae67382015560408401517f1b6847dc741a1b0cd08d278845f9d819d87b734759afb55fe2de5cb82a9ae67482015591517f1b6847dc741a1b0cd08d278845f9d819d87b734759afb55fe2de5cb82a9ae675830155517f1b6847dc741a1b0cd08d278845f9d819d87b734759afb55fe2de5cb82a9ae67690910155600754610d8a90836118e5565b60075560035460408051637e062a3560e11b815290516001600160a01b039092169163fc0c546a91600480820192602092909190829003018186803b158015610dd257600080fd5b505afa158015610de6573d6000803e3d6000fd5b505050506040513d6020811015610dfc57600080fd5b5051600354604080516323b872dd60e01b81523360048201526001600160a01b03928316602482015260448101899052905191909216916323b872dd9160648083019260209291908290030181600087803b158015610e5a57600080fd5b505af1158015610e6e573d6000803e3d6000fd5b505050506040513d6020811015610e8457600080fd5b5051610ec15760405162461bcd60e51b815260040180806020018281038252602d815260200180612299602d913960400191505060405180910390fd5b7ff346961af4c52f314df1b45964746280fe409abb959d4a2458d58f79408b1fe88585610eec61084f565b60408051938452602084019290925282820152519081900360600190a15050505050565b6000546001600160a01b031690565b60015460408051637e062a3560e11b815290516000926001600160a01b03169163fc0c546a916004808301926020929190829003018186803b15801561075b57600080fd5b600254604080516316d3df1560e31b815290516000926001600160a01b03169163b69ef8a8916004808301926020929190829003018186803b15801561075b57600080fd5b610fb16118e1565b6000546001600160a01b03908116911614611001576040805162461bcd60e51b815260206004820181905260248201526000805160206124ba833981519152604482015290519081900360640190fd5b600061100b610f64565b1161105d576040805162461bcd60e51b815260206004820152601e60248201527f546f6b656e4765797365723a204e6f7468696e6720746f207265736375650000604482015290519081900360640190fd5b600254604080516316d3df1560e31b815290516001600160a01b039092169163a9059cbb918491849163b69ef8a8916004808301926020929190829003018186803b1580156110ab57600080fd5b505afa1580156110bf573d6000803e3d6000fd5b505050506040513d60208110156110d557600080fd5b5051604080516001600160e01b031960e086901b1681526001600160a01b03909316600484015260248301919091525160448083019260209291908290030181600087803b15801561112657600080fd5b505af115801561113a573d6000803e3d6000fd5b505050506040513d602081101561115057600080fd5b505161118d5760405162461bcd60e51b81526004018080602001828103825260348152602001806122656034913960400191505060405180910390fd5b50565b6011546001600160a01b031633146111d95760405162461bcd60e51b81526004018080602001828103825260348152602001806123a46034913960400191505060405180910390fd5b610b1f848461193f565b60105490565b6011546000906001600160a01b031633146112355760405162461bcd60e51b81526004018080602001828103825260348152602001806123a46034913960400191505060405180910390fd5b61097b838361193f565b600080600080600080611250611dec565b50600061126e600854610831600a5442611f8090919063ffffffff16565b600954909150611284908263ffffffff6118e516565b60095542600a8190556001600160a01b0389166000908152600d602052604081208054600282015491936112c292610831919063ffffffff611f8016565b60018301549091506112da908263ffffffff6118e516565b60018301554260028301556009546000906112f657600061130c565b61130c60095461083d8560010154610831610f64565b905061131661084f565b61131e610f64565b600190940154600954919d949c509a5098509650429550909350505050565b6113456118e1565b6000546001600160a01b03908116911614611395576040805162461bcd60e51b815260206004820181905260248201526000805160206124ba833981519152604482015290519081900360640190fd5b6001600160a01b0381166113da5760405162461bcd60e51b81526004018080602001828103825260268152602001806122f66026913960400191505060405180910390fd5b600080546040516001600160a01b03808516939216917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e091a3600080546001600160a01b0319166001600160a01b0392909216919091179055565b600061143f6118e1565b6000546001600160a01b0390811691161461148f576040805162461bcd60e51b815260206004820181905260248201526000805160206124ba833981519152604482015290519081900360640190fd5b611497611dec565b5090565b60006114a5610f1f565b905090565b600081116114e95760405162461bcd60e51b81526004018080602001828103825260218152602001806124786021913960400191505060405180910390fd5b6001600160a01b03821661152e5760405162461bcd60e51b815260040180806020018281038252602881526020018061234d6028913960400191505060405180910390fd5b600854158061154457506000611542610b35565b115b61157f5760405162461bcd60e51b815260040180806020018281038252604a8152602001806124da604a913960600191505060405180910390fd5b600080600854116115a357600c5461159e90839063ffffffff61184616565b6115c1565b6115c16115ae610b35565b60085461083d908563ffffffff61184616565b9050600081116116025760405162461bcd60e51b81526004018080602001828103825260268152602001806123d86026913960400191505060405180910390fd5b61160b8361123f565b505050506001600160a01b0385166000908152600d6020526040902080549092506116379150836118e5565b815542600282015561164761224a565b506040805180820182528381524260208083019182526001600160a01b0388166000908152600e825293842080546001818101835591865291909420835160029092020190815590519201919091556008546116a9908463ffffffff6118e516565b60085560015460408051637e062a3560e11b815290516001600160a01b039092169163fc0c546a91600480820192602092909190829003018186803b1580156116f157600080fd5b505afa158015611705573d6000803e3d6000fd5b505050506040513d602081101561171b57600080fd5b5051600154604080516323b872dd60e01b81526001600160a01b038a81166004830152928316602482015260448101889052905191909216916323b872dd9160648083019260209291908290030181600087803b15801561177b57600080fd5b505af115801561178f573d6000803e3d6000fd5b505050506040513d60208110156117a557600080fd5b50516117e25760405162461bcd60e51b815260040180806020018281038252602e81526020018061244a602e913960400191505060405180910390fd5b846001600160a01b03167fc65e53b88159e7d2c0fc12a0600072e28ae53ff73b4c1715369c30f16093514285611817886107f2565b6040805192835260208301919091526060828201819052600090830152519081900360a00190a2505050505050565b60008261185557506000610849565b8282028284828161186257fe5b041461097b5760405162461bcd60e51b81526004018080602001828103825260218152602001806124996021913960400191505060405180910390fd5b600061097b83836040518060400160405280601a81526020017f536166654d6174683a206469766973696f6e206279207a65726f000000000000815250611fc2565b3390565b60008282018381101561097b576040805162461bcd60e51b815260206004820152601b60248201527f536166654d6174683a206164646974696f6e206f766572666c6f770000000000604482015290519081900360640190fd5b600061194a8361123f565b505050505050600061197061195d610b35565b60085461083d908663ffffffff61184616565b9050600081116119b15760405162461bcd60e51b81526004018080602001828103825260308152602001806122c66030913960400191505060405180910390fd5b6001600160a01b0384166000908152600d60209081526040808320600e9092528220909183815b8115611af3578354600090859060001981019081106119f357fe5b906000526020600020906002020190506000611a1c826001015442611f8090919063ffffffff16565b82549091506000908510611aa0578254611a3c908363ffffffff61184616565b9050611a49848284612064565b9350611a5b868263ffffffff6118e516565b8354909650611a7190869063ffffffff611f8016565b945086805480611a7d57fe5b600082815260208120600260001990930192830201818155600101559055611aeb565b611ab0858363ffffffff61184616565b9050611abd848284612064565b9350611acf868263ffffffff6118e516565b8354909650611ae4908663ffffffff611f8016565b8355600094505b5050506119d8565b6001850154611b08908463ffffffff611f8016565b60018601558454611b1f908763ffffffff611f8016565b8555600954611b34908463ffffffff611f8016565b600955600854611b4a908763ffffffff611f8016565b6008556001546040805163a9059cbb60e01b81526001600160a01b038c81166004830152602482018c90529151919092169163a9059cbb9160448083019260209291908290030181600087803b158015611ba357600080fd5b505af1158015611bb7573d6000803e3d6000fd5b505050506040513d6020811015611bcd57600080fd5b5051611c0a5760405162461bcd60e51b81526004018080602001828103825260308152602001806125516030913960400191505060405180910390fd5b80611c13610f64565b10611d33576002546040805163a9059cbb60e01b81526001600160a01b038c81166004830152602482018590529151919092169163a9059cbb9160448083019260209291908290030181600087803b158015611c6e57600080fd5b505af1158015611c82573d6000803e3d6000fd5b505050506040513d6020811015611c9857600080fd5b5051611cd55760405162461bcd60e51b815260040180806020018281038252603181526020018061231c6031913960400191505060405180910390fd5b6040805182815290516001600160a01b038b16917f896e034966eaaf1adc54acc0f257056febbd300c9e47182cf761982cf1f5e430919081900360200190a26001600160a01b0389166000908152600f602052604090208054820190555b886001600160a01b03167faf01bfc8475df280aca00b578c4a948e6d95700f0db8c13365240f7f973c875489611d688c6107f2565b6040805192835260208301919091526060828201819052600090830152519081900360a00190a26008541580611da557506000611da3610b35565b115b611de05760405162461bcd60e51b815260040180806020018281038252604c8152602001806123fe604c913960600191505060405180910390fd5b98975050505050505050565b60008080611df861084f565b905060075460001415611e0d57809150611e71565b6000805b601054811015611e3e57611e34611e27826120fe565b839063ffffffff6118e516565b9150600101611e11565b50600754611e569061083d838563ffffffff61184616565b600754909350611e6c908263ffffffff611f8016565b600755505b8115611f7a576003546002546040805163a9059cbb60e01b81526001600160a01b039283166004820152602481018690529051919092169163a9059cbb9160448083019260209291908290030181600087803b158015611ed057600080fd5b505af1158015611ee4573d6000803e3d6000fd5b505050506040513d6020811015611efa57600080fd5b5051611f375760405162461bcd60e51b815260040180806020018281038252602f815260200180612375602f913960400191505060405180910390fd5b7f2e444eb379b177e88ce0649c6110a3b01099f03e297127919dd5e3b63a761a9c82611f6161084f565b6040805192835260208301919091528051918290030190a15b50905090565b600061097b83836040518060400160405280601e81526020017f536166654d6174683a207375627472616374696f6e206f766572666c6f7700008152506121c1565b6000818361204e5760405162461bcd60e51b81526004018080602001828103825283818151815260200191508051906020019080838360005b83811015612013578181015183820152602001611ffb565b50505050905090810190601f1680156120405780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b50600083858161205a57fe5b0495945050505050565b60008061207960095461083d86610831610f64565b9050600654831061209c57612094858263ffffffff6118e516565b91505061097b565b6000600454600a0a905060006120e18261083d856108316120d260065461083d8c6108316005548c611f8090919063ffffffff16565b6005549063ffffffff6118e516565b90506120f3878263ffffffff6118e516565b979650505050505050565b6000806010838154811061210e57fe5b906000526020600020906005020190508060000154816001015410612137576000915050610612565b6003810154600090421061216c576001820154825461215b9163ffffffff611f8016565b60038301546002840155905061219c565b612193826004015461083d8460000154610831866002015442611f8090919063ffffffff16565b42600284015590505b60018201546121b1908263ffffffff6118e516565b6001909201919091559050919050565b600081848411156122135760405162461bcd60e51b8152602060048201818152835160248401528351909283926044909101919085019080838360008315612013578181015183820152602001611ffb565b505050900390565b6040518060a0016040528060008152602001600081526020016000815260200160008152602001600081525090565b60405180604001604052806000815260200160008152509056fe546f6b656e4765797365723a2072657363756520726577617264732066726f6d207265776172647320706f6f6c206661696c6564546f6b656e4765797365723a207472616e7366657220696e746f206c6f636b656420706f6f6c206661696c6564546f6b656e4765797365723a20556e61626c6520746f20756e7374616b6520616d6f756e74207468697320736d616c6c4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061646472657373546f6b656e4765797365723a207472616e73666572206f7574206f6620756e6c6f636b656420706f6f6c206661696c6564546f6b656e4765797365723a2062656e6566696369617279206973207a65726f2061646472657373546f6b656e4765797365723a207472616e73666572206f7574206f66206c6f636b656420706f6f6c206661696c656454686973206d6574686f642063616e2062652063616c6c65642062792074686520676579736572206d616e61676572206f6e6c79546f6b656e4765797365723a205374616b6520616d6f756e7420697320746f6f20736d616c6c546f6b656e4765797365723a204572726f7220756e7374616b696e672e205374616b696e67207368617265732065786973742c20627574206e6f207374616b696e6720746f6b656e7320646f546f6b656e4765797365723a207472616e7366657220696e746f207374616b696e6720706f6f6c206661696c6564546f6b656e4765797365723a207374616b6520616d6f756e74206973207a65726f536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f774f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572546f6b656e4765797365723a20496e76616c69642073746174652e205374616b696e67207368617265732065786973742c20627574206e6f207374616b696e6720746f6b656e7320646f546f6b656e4765797365723a2072656163686564206d6178696d756d20756e6c6f636b207363686564756c6573546f6b656e4765797365723a207472616e73666572206f7574206f66207374616b696e6720706f6f6c206661696c6564a2646970667358221220b2a4c50fd160c7d3aeaeb2c5615fea1e413677588d4d02d25216fc2787e6035e64736f6c63430006060033

25691:24294:0:-:0;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;25691:24294:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;9;2:12;30181:109:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;30181:109:0;-1:-1:-1;;;;;30181:109:0;;:::i;:::-;;;;;;;;;;;;;;;;30908:171;;;:::i;:::-;;;;-1:-1:-1;;;;;30908:171:0;;;;;;;;;;;;;;26504:29;;;:::i;31337:312::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;31337:312:0;;;;;;;;;;;;;;;;;;;27:11:-1;11:28;;8:2;;;52:1;49;42:12;8:2;31337:312:0;;41:9:-1;34:4;18:14;14:25;11:40;8:2;;;64:1;61;54:12;8:2;31337:312:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;-1:-1;31337:312:0;;-1:-1:-1;31337:312:0;-1:-1:-1;31337:312:0;:::i;:::-;;26465:32;;;:::i;41486:334::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;41486:334:0;-1:-1:-1;;;;;41486:334:0;;:::i;44422:100::-;;;:::i;49648:230::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;49648:230:0;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;27999:39;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;27999:39:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49886:96;;;:::i;26673:37::-;;;:::i;7889:148::-;;;:::i;26540:33::-;;;:::i;31921:346::-;;;;;;15:3:-1;10;7:12;4:2;;;32:1;29;22:12;4:2;-1:-1;;;;;31921:346:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:11:-1;11:28;;8:2;;;52:1;49;42:12;8:2;31921:346:0;;41:9:-1;34:4;18:14;14:25;11:40;8:2;;;64:1;61;54:12;8:2;31921:346:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;-1:-1;31921:346:0;;-1:-1:-1;31921:346:0;-1:-1:-1;31921:346:0;:::i;28047:28::-;;;:::i;41928:110::-;;;:::i;26630:36::-;;;:::i;45355:1291::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;45355:1291:0;;;;;;;:::i;7247:79::-;;;:::i;30723:102::-;;;:::i;44610:104::-;;;:::i;30344:303::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;30344:303:0;-1:-1:-1;;;;;30344:303:0;;:::i;34584:305::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;34584:305:0;;;;;;;;;;;;;;;;;;;27:11:-1;11:28;;8:2;;;52:1;49;42:12;8:2;34584:305:0;;41:9:-1;34:4;18:14;14:25;11:40;8:2;;;64:1;61;54:12;8:2;34584:305:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;-1:-1;34584:305:0;;-1:-1:-1;34584:305:0;-1:-1:-1;34584:305:0;:::i;44784:109::-;;;:::i;35065:292::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;;35065:292:0;;;;;;;;:::i;42890:1446::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;42890:1446:0;-1:-1:-1;;;;;42890:1446:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8192:244;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;8192:244:0;-1:-1:-1;;;;;8192:244:0;;:::i;46902:93::-;;;:::i;42279:110::-;;;:::i;30181:109::-;-1:-1:-1;;;;;30264:18:0;;30237:7;30264:18;;;:12;:18;;;;;;30181:109;;;;:::o;30908:171::-;31012:11;;:19;;;-1:-1:-1;;;31012:19:0;;;;30961:6;;-1:-1:-1;;;;;31012:11:0;;:17;;:19;;;;;;;;;;;;;;:11;:19;;;2:2:-1;;;;27:1;24;17:12;2:2;31012:19:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;31012:19:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;31012:19:0;30987:13;;:21;;;-1:-1:-1;;;30987:21:0;;;;-1:-1:-1;;;;;30987:44:0;;;;:13;;;;:19;;:21;;;;;31012:19;;30987:21;;;;;;;;:13;:21;;;2:2:-1;;;;27:1;24;17:12;2:2;30987:21:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;30987:21:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;30987:21:0;-1:-1:-1;;;;;30987:44:0;;30980:52;;;;31050:13;;;;;;;;;-1:-1:-1;;;;;31050:13:0;-1:-1:-1;;;;;31050:19:0;;:21;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;31050:21:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;31050:21:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;31050:21:0;;-1:-1:-1;30908:171:0;:::o;26504:29::-;;;;:::o;31337:312::-;31490:13;;-1:-1:-1;;;;;31490:13:0;31507:10;31490:27;31468:129;;;;-1:-1:-1;;;31468:129:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31608:33;31618:6;31626;31634;31608:9;:33::i;:::-;31337:312;;;;:::o;26465:32::-;;;;:::o;41486:334::-;41590:7;41656:1;41635:18;;:22;:177;;41811:1;41635:177;;;41754:18;;-1:-1:-1;;;;;41695:17:0;;;;;;:11;:17;;;;;:31;41677:114;;41754:18;41677:50;;:13;:11;:13::i;:::-;:17;:50;:17;:50;:::i;:::-;:54;:114;:54;:114;:::i;:::-;41615:197;41486:334;-1:-1:-1;;41486:334:0:o;44422:100::-;44493:11;;:21;;;-1:-1:-1;;;44493:21:0;;;;44466:7;;-1:-1:-1;;;;;44493:11:0;;:19;;:21;;;;;;;;;;;;;;:11;:21;;;2:2:-1;;;;27:1;24;17:12;49648:230:0;49795:4;7469:12;:10;:12::i;:::-;7459:6;;-1:-1:-1;;;;;7459:6:0;;;:22;;;7451:67;;;;;-1:-1:-1;;;7451:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;7451:67:0;;;;;;;;;;;;;;;49819:12:::1;::::0;:51:::1;::::0;;-1:-1:-1;;;49819:51:0;;-1:-1:-1;;;;;49819:51:0;;::::1;;::::0;::::1;::::0;;;::::1;::::0;;;;;;;;;;;;:12;;;::::1;::::0;:24:::1;::::0;:51;;;;;::::1;::::0;;;;;;;;:12:::1;::::0;:51;::::1;;2:2:-1::0;::::1;;;27:1;24::::0;17:12:::1;2:2;49819:51:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;49819:51:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28::::0;21:12:::1;4:2;-1:-1:::0;49819:51:0;;-1:-1:-1;7529:1:0::1;49648:230:::0;;;;;:::o;27999:39::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;27999:39:0;;;;;:::o;49886:96::-;49945:4;49886:96;:::o;26673:37::-;;;;:::o;7889:148::-;7469:12;:10;:12::i;:::-;7459:6;;-1:-1:-1;;;;;7459:6:0;;;:22;;;7451:67;;;;;-1:-1:-1;;;7451:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;7451:67:0;;;;;;;;;;;;;;;7996:1:::1;7980:6:::0;;7959:40:::1;::::0;-1:-1:-1;;;;;7980:6:0;;::::1;::::0;7959:40:::1;::::0;7996:1;;7959:40:::1;8027:1;8010:19:::0;;-1:-1:-1;;;;;;8010:19:0::1;::::0;;7889:148::o;26540:33::-;;;;:::o;31921:346::-;7469:12;:10;:12::i;:::-;7459:6;;-1:-1:-1;;;;;7459:6:0;;;:22;;;7451:67;;;;;-1:-1:-1;;;7451:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;7451:67:0;;;;;;;;;;;;;;;32110:13:::1;::::0;-1:-1:-1;;;;;32110:13:0::1;32127:10;32110:27;32088:129;;;;-1:-1:-1::0;;;32088:129:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32228:31;32238:6;32246:4;32252:6;32228:9;:31::i;:::-;31921:346:::0;;;;;:::o;28047:28::-;;;-1:-1:-1;;;;;28047:28:0;;:::o;41928:110::-;42008:12;;:22;;;-1:-1:-1;;;42008:22:0;;;;41981:7;;-1:-1:-1;;;;;42008:12:0;;:20;;:22;;;;;;;;;;;;;;:12;:22;;;2:2:-1;;;;27:1;24;17:12;26630:36:0;;;;:::o;45355:1291::-;7469:12;:10;:12::i;:::-;7459:6;;-1:-1:-1;;;;;7459:6:0;;;:22;;;7451:67;;;;;-1:-1:-1;;;7451:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;7451:67:0;;;;;;;;;;;;;;;45512:19:::1;::::0;45487:15:::1;:22:::0;:44:::1;45465:139;;;;-1:-1:-1::0;;;45465:139:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45695:28;45712:10;45695:16;:28::i;:::-;;;;;;;45736:20;45759:13;:11;:13::i;:::-;45736:36;;45783:26;45841:1:::0;45826:12:::1;:16;45825:139;;45941:22;::::0;45930:34:::1;::::0;:6;;:34:::1;:10;:34;:::i;:::-;45825:139;;;45863:47;45897:12;45863:29;45885:6;45863:17;;:21;;:29;;;;:::i;:47::-;45783:181;;45977:30;;:::i;:::-;46018:49:::0;;;46112:3:::1;46078:31;::::0;::::1;:37:::0;;;46146:20:::1;::::0;46154:11;46146:20:::1;:7;:20;:::i;:::-;46126:17;::::0;::::1;:40:::0;;;46177:20:::1;::::0;::::1;:34:::0;;;46222:15:::1;27:10:-1::0;;39:1:::1;23:18:::0;::::1;45:23:::0;;-1:-1;46222:30:0;;;;;;;::::1;::::0;;::::1;::::0;;::::1;::::0;::::1;::::0;::::1;::::0;;;;;::::1;::::0;::::1;::::0;;;;;;;;;;;;;;;;;46285:17:::1;::::0;:41:::1;::::0;46307:18;46285:21:::1;:41::i;:::-;46265:17;:61:::0;46361:11:::1;::::0;:19:::1;::::0;;-1:-1:-1;;;46361:19:0;;;;-1:-1:-1;;;;;46361:11:0;;::::1;::::0;:17:::1;::::0;:19:::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;:11;:19;::::1;;2:2:-1::0;::::1;;;27:1;24::::0;17:12:::1;2:2;46361:19:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;46361:19:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28::::0;21:12:::1;4:2;-1:-1:::0;46361:19:0;46449:11:::1;::::0;46361:140:::1;::::0;;-1:-1:-1;;;46361:140:0;;46412:10:::1;46361:140;::::0;::::1;::::0;-1:-1:-1;;;;;46449:11:0;;::::1;46361:140:::0;;;;;;;;;;;;:32;;;::::1;::::0;::::1;::::0;:140;;;;;:19:::1;::::0;:140;;;;;;;46449:11:::1;46361:32:::0;:140;::::1;;2:2:-1::0;::::1;;;27:1;24::::0;17:12:::1;2:2;46361:140:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;46361:140:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28::::0;21:12:::1;4:2;-1:-1:::0;46361:140:0;46339:235:::1;;;;-1:-1:-1::0;;;46339:235:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46590:48;46603:6;46611:11;46624:13;:11;:13::i;:::-;46590:48;::::0;;;;;::::1;::::0;::::1;::::0;;;;;;;;;;;;;;;;::::1;7529:1;;;45355:1291:::0;;:::o;7247:79::-;7285:7;7312:6;-1:-1:-1;;;;;7312:6:0;7247:79;:::o;30723:102::-;30797:12;;:20;;;-1:-1:-1;;;30797:20:0;;;;30771:6;;-1:-1:-1;;;;;30797:12:0;;:18;;:20;;;;;;;;;;;;;;:12;:20;;;2:2:-1;;;;27:1;24;17:12;44610:104:0;44683:13;;:23;;;-1:-1:-1;;;44683:23:0;;;;44656:7;;-1:-1:-1;;;;;44683:13:0;;:21;;:23;;;;;;;;;;;;;;:13;:23;;;2:2:-1;;;;27:1;24;17:12;30344:303:0;7469:12;:10;:12::i;:::-;7459:6;;-1:-1:-1;;;;;7459:6:0;;;:22;;;7451:67;;;;;-1:-1:-1;;;7451:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;7451:67:0;;;;;;;;;;;;;;;30437:1:::1;30419:15;:13;:15::i;:::-;:19;30411:62;;;::::0;;-1:-1:-1;;;30411:62:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;30506:13;::::0;30535:23:::1;::::0;;-1:-1:-1;;;30535:23:0;;;;-1:-1:-1;;;;;30506:13:0;;::::1;::::0;:22:::1;::::0;30529:4;;30506:13;;30535:21:::1;::::0;:23:::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;30506:13;30535:23;::::1;;2:2:-1::0;::::1;;;27:1;24::::0;17:12:::1;2:2;30535:23:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;30535:23:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28::::0;21:12:::1;4:2;-1:-1:::0;30535:23:0;30506:53:::1;::::0;;-1:-1:-1;;;;;;30506:53:0::1;::::0;;;;;;-1:-1:-1;;;;;30506:53:0;;::::1;;::::0;::::1;::::0;;;;;;;;;;;;;;30535:23:::1;::::0;30506:53;;;;;;;-1:-1:-1;30506:53:0;;::::1;;2:2:-1::0;::::1;;;27:1;24::::0;17:12:::1;2:2;30506:53:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;30506:53:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28::::0;21:12:::1;4:2;-1:-1:::0;30506:53:0;30484:155:::1;;;;-1:-1:-1::0;;;30484:155:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30344:303:::0;:::o;34584:305::-;34739:13;;-1:-1:-1;;;;;34739:13:0;34756:10;34739:27;34717:129;;;;-1:-1:-1;;;34717:129:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34857:24;34866:6;34874;34857:8;:24::i;44784:109::-;44863:15;:22;44784:109;:::o;35065:292::-;35200:13;;35153:7;;-1:-1:-1;;;;;35200:13:0;35217:10;35200:27;35178:129;;;;-1:-1:-1;;;35178:129:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35325:24;35334:6;35342;35325:8;:24::i;42890:1446::-;42978:7;43000;43022;43044;43066;43088;43123:15;:13;:15::i;:::-;;43181:30;43227:60;43268:18;;43227:36;43235:27;;43227:3;:7;;:36;;;;:::i;:60::-;43326:25;;43181:106;;-1:-1:-1;43326:77:0;;43181:106;43326:77;:29;:77;:::i;:::-;43298:25;:105;43444:3;43414:27;:33;;;-1:-1:-1;;;;;43516:17:0;;-1:-1:-1;43516:17:0;;;:11;:17;;;;;43659:20;;43602:33;;;;43516:17;;43594:100;;:42;;43444:3;43594:42;:7;:42;:::i;:100::-;43734:26;;;;43544:150;;-1:-1:-1;43734:82:0;;43544:150;43734:82;:30;:82;:::i;:::-;43705:26;;;:111;43863:3;43827:33;;;:39;43920:25;;-1:-1:-1;;43919:190:0;;44108:1;43919:190;;;43970:118;44044:25;;43970:47;43990:6;:26;;;43970:15;:13;:15::i;:118::-;43879:230;;44144:13;:11;:13::i;:::-;44172:15;:13;:15::i;:::-;44202:26;;;;;44243:25;;44122:206;;;;-1:-1:-1;44202:26:0;-1:-1:-1;44243:25:0;-1:-1:-1;44283:16:0;-1:-1:-1;44314:3:0;;-1:-1:-1;42890:1446:0;;-1:-1:-1;;;;42890:1446:0:o;8192:244::-;7469:12;:10;:12::i;:::-;7459:6;;-1:-1:-1;;;;;7459:6:0;;;:22;;;7451:67;;;;;-1:-1:-1;;;7451:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;7451:67:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;8281:22:0;::::1;8273:73;;;;-1:-1:-1::0;;;8273:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8383:6;::::0;;8362:38:::1;::::0;-1:-1:-1;;;;;8362:38:0;;::::1;::::0;8383:6;::::1;::::0;8362:38:::1;::::0;::::1;8411:6;:17:::0;;-1:-1:-1;;;;;;8411:17:0::1;-1:-1:-1::0;;;;;8411:17:0;;;::::1;::::0;;;::::1;::::0;;8192:244::o;46902:93::-;46952:7;7469:12;:10;:12::i;:::-;7459:6;;-1:-1:-1;;;;;7459:6:0;;;:22;;;7451:67;;;;;-1:-1:-1;;;7451:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;7451:67:0;;;;;;;;;;;;;;;46972:15:::1;:13;:15::i;:::-;;46902:93:::0;:::o;42279:110::-;42328:7;42363:17;:15;:17::i;:::-;42348:33;;42279:110;:::o;32554:1761::-;32696:1;32687:6;:10;32679:56;;;;-1:-1:-1;;;32679:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;32768:25:0;;32746:115;;;;-1:-1:-1;;;32746:115:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32894:18;;:23;;:44;;;32937:1;32921:13;:11;:13::i;:::-;:17;32894:44;32872:168;;;;-1:-1:-1;;;32872:168:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33055:27;33120:1;33099:18;;:22;33098:147;;33222:22;;33211:34;;:6;;:34;:10;:34;:::i;:::-;33098:147;;;33142:49;33177:13;:11;:13::i;:::-;33142:18;;:30;;33165:6;33142:30;:22;:30;:::i;:49::-;33055:190;;33302:1;33280:19;:23;33258:111;;;;-1:-1:-1;;;33258:111:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33382:29;33399:11;33382:16;:29::i;:::-;-1:-1:-1;;;;;;;;;33483:24:0;;33455:25;33483:24;;;:11;:24;;;;;33541:20;;33483:24;;-1:-1:-1;33541:45:0;;-1:-1:-1;33566:19:0;33541:24;:45::i;:::-;33518:68;;33633:3;33597:33;;;:39;33649:21;;:::i;:::-;-1:-1:-1;33673:31:0;;;;;;;;;;;33700:3;33673:31;;;;;;;-1:-1:-1;;;;;33715:24:0;;-1:-1:-1;33715:24:0;;;:11;:24;;;;;27:10:-1;;39:1;23:18;;;45:23;;33715:39:0;;;;;;;;;;;;;;;;;;;;;;;;;33821:18;;:43;;33679:19;33821:43;:22;:43;:::i;:::-;33800:18;:64;34017:12;;:20;;;-1:-1:-1;;;34017:20:0;;;;-1:-1:-1;;;;;34017:12:0;;;;:18;;:20;;;;;;;;;;;;;;;:12;:20;;;2:2:-1;;;;27:1;24;17:12;2:2;34017:20:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;34017:20:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;34017:20:0;34102:12;;34017:138;;;-1:-1:-1;;;34017:138:0;;-1:-1:-1;;;;;34017:138:0;;;;;;;34102:12;;;34017:138;;;;;;;;;;;;:33;;;;;;;:138;;;;;:20;;:138;;;;;;;34102:12;34017:33;:138;;;2:2:-1;;;;27:1;24;17:12;2:2;34017:138:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;34017:138:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;34017:138:0;33995:234;;;;-1:-1:-1;;;33995:234:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34254:11;-1:-1:-1;;;;;34247:60:0;;34267:6;34275:27;34290:11;34275:14;:27::i;:::-;34247:60;;;;;;;;;;;;;;;;;;;;-1:-1:-1;34247:60:0;;;;;;;;;;;;;32554:1761;;;;;;:::o;2223:471::-;2281:7;2526:6;2522:47;;-1:-1:-1;2556:1:0;2549:8;;2522:47;2593:5;;;2597:1;2593;:5;:1;2617:5;;;;;:10;2609:56;;;;-1:-1:-1;;;2609:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3170:132;3228:7;3255:39;3259:1;3262;3255:39;;;;;;;;;;;;;;;;;:3;:39::i;5874:106::-;5962:10;5874:106;:::o;869:181::-;927:7;959:5;;;983:6;;;;975:46;;;;;-1:-1:-1;;;975:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;35662:3829;35727:7;35747:22;35764:4;35747:16;:22::i;:::-;;;;;;;35782:27;35825:49;35860:13;:11;:13::i;:::-;35825:18;;:30;;35848:6;35825:30;:22;:30;:::i;:49::-;35782:92;;35931:1;35909:19;:23;35887:121;;;;-1:-1:-1;;;35887:121:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;36080:17:0;;36052:25;36080:17;;;:11;:17;;;;;;;;36140:11;:17;;;;;36080;;36313:19;36052:25;36378:1607;36385:20;;36378:1607;;36462:20;;36422:23;;36448:13;;-1:-1:-1;;36462:24:0;;;36448:39;;;;;;;;;;;;;;;;36422:65;;36502:20;36525:31;36533:9;:22;;;36525:3;:7;;:31;;;;:::i;:::-;36632:23;;36502:54;;-1:-1:-1;36571:36:0;;36632:43;-1:-1:-1;36628:1346:0;;36727:23;;:81;;36777:12;36727:81;:27;:81;:::i;:::-;36696:112;;36842:156;36881:12;36916:28;36967:12;36842:16;:156::i;:::-;36827:171;-1:-1:-1;37047:99:0;:25;37099:28;37047:99;:29;:99;:::i;:::-;37227:23;;37019:127;;-1:-1:-1;37184:85:0;;:16;;:85;:20;:85;:::i;:::-;37165:104;;37288:13;:19;;;;;;;;;;;;;;;-1:-1:-1;;37288:19:0;;;;;;;;;;;;;;;36628:1346;;;37379:74;:16;37422:12;37379:74;:20;:74;:::i;:::-;37348:105;;37487:156;37526:12;37561:28;37612:12;37487:16;:156::i;:::-;37472:171;-1:-1:-1;37690:99:0;:25;37742:28;37690:99;:29;:99;:::i;:::-;37834:23;;37662:127;;-1:-1:-1;37834:85:0;;37884:16;37834:85;:27;:85;:::i;:::-;37808:111;;:23;;-1:-1:-1;36628:1346:0;36378:1607;;;;;;38024:26;;;;:81;;38069:25;38024:81;:30;:81;:::i;:::-;37995:26;;;:110;38139:20;;:45;;38164:19;38139:45;:24;:45;:::i;:::-;38116:68;;38355:25;;:80;;38399:25;38355:80;:29;:80;:::i;:::-;38327:25;:108;38467:18;;:43;;38490:19;38467:43;:22;:43;:::i;:::-;38446:18;:64;38662:12;;:35;;;-1:-1:-1;;;38662:35:0;;-1:-1:-1;;;;;38662:35:0;;;;;;;;;;;;;;;:12;;;;;:21;;:35;;;;;;;;;;;;;;:12;;:35;;;2:2:-1;;;;27:1;24;17:12;2:2;38662:35:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;38662:35:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;38662:35:0;38640:133;;;;-1:-1:-1;;;38640:133:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38892:12;38873:15;:13;:15::i;:::-;:31;38869:334;;38947:13;;:42;;;-1:-1:-1;;;38947:42:0;;-1:-1:-1;;;;;38947:42:0;;;;;;;;;;;;;;;:13;;;;;:22;;:42;;;;;;;;;;;;;;:13;;:42;;;2:2:-1;;;;27:1;24;17:12;2:2;38947:42:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;38947:42:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;38947:42:0;38921:153;;;;-1:-1:-1;;;38921:153:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39094:33;;;;;;;;-1:-1:-1;;;;;39094:33:0;;;;;;;;;;;;;-1:-1:-1;;;;;39157:18:0;;;;;;:12;:18;;;;;:34;;;;;;38869:334;39229:4;-1:-1:-1;;;;;39220:48:0;;39235:6;39243:20;39258:4;39243:14;:20::i;:::-;39220:48;;;;;;;;;;;;;;;;;;;;-1:-1:-1;39220:48:0;;;;;;;;;;;;;39303:18;;:23;;:44;;;39346:1;39330:13;:11;:13::i;:::-;:17;39303:44;39281:170;;;;-1:-1:-1;;;39281:170:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39471:12;35662:3829;-1:-1:-1;;;;;;;;35662:3829:0:o;47003:982::-;47045:7;;;47125:13;:11;:13::i;:::-;47102:36;;47155:17;;47176:1;47155:22;47151:496;;;47211:12;47194:29;;47151:496;;;47256:22;;47297:148;47321:15;:22;47317:26;;47297:148;;;47386:43;47405:23;47426:1;47405:20;:23::i;:::-;47386:14;;:43;:18;:43;:::i;:::-;47369:60;-1:-1:-1;47345:3:0;;47297:148;;;-1:-1:-1;47531:17:0;;47476:87;;:32;:14;47495:12;47476:32;:18;:32;:::i;:87::-;47598:17;;47459:104;;-1:-1:-1;47598:37:0;;47620:14;47598:37;:21;:37;:::i;:::-;47578:17;:57;-1:-1:-1;47151:496:0;47663:18;;47659:285;;47724:11;;47753:13;;47724:60;;;-1:-1:-1;;;47724:60:0;;-1:-1:-1;;;;;47753:13:0;;;47724:60;;;;;;;;;;;;:11;;;;;:20;;:60;;;;;;;;;;;;;;:11;;:60;;;2:2:-1;;;;27:1;24;17:12;2:2;47724:60:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;47724:60:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;47724:60:0;47698:169;;;;-1:-1:-1;;;47698:169:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47887:45;47902:14;47918:13;:11;:13::i;:::-;47887:45;;;;;;;;;;;;;;;;;;;;;;47659:285;-1:-1:-1;47963:14:0;-1:-1:-1;47003:982:0;:::o;1333:136::-;1391:7;1418:43;1422:1;1425;1418:43;;;;;;;;;;;;;;;;;:3;:43::i;3798:278::-;3884:7;3919:12;3912:5;3904:28;;;;-1:-1:-1;;;3904: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;3904:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3943:9;3959:1;3955;:5;;;;;;;3798:278;-1:-1:-1;;;;;3798:278:0:o;40467:863::-;40629:7;40649:23;40688:103;40751:25;;40688:40;40708:19;40688:15;:13;:15::i;:103::-;40649:142;;40824:14;;40808:12;:30;40804:110;;40862:40;:19;40886:15;40862:40;:23;:40;:::i;:::-;40855:47;;;;;40804:110;40926:21;40954:13;;40950:2;:17;40926:41;;40978:21;41015:249;41250:13;41015:212;41211:15;41015:173;41066:107;41140:14;;41066:47;41100:12;41066:29;41084:10;;41066:13;:17;;:29;;;;:::i;:107::-;41015:10;;;:173;:32;:173;:::i;:249::-;40978:286;-1:-1:-1;41284:38:0;:19;40978:286;41284:38;:23;:38;:::i;:::-;41277:45;40467:863;-1:-1:-1;;;;;;;40467:863:0:o;48355:971::-;48413:7;48433:31;48467:15;48483:1;48467:18;;;;;;;;;;;;;;;;;;48433:52;;48529:8;:28;;;48502:8;:23;;;:55;48498:96;;48581:1;48574:8;;;;;48498:96;48729:17;;;;48606:22;;48722:3;:24;48718:487;;48832:23;;;;48799:28;;:57;;;:32;:57;:::i;:::-;48920:17;;;;48886:31;;;:51;48763:108;-1:-1:-1;48718:487:0;;;48987:154;49120:8;:20;;;48987:110;49068:8;:28;;;48987:58;49013:8;:31;;;48987:3;:25;;:58;;;;:::i;:154::-;49190:3;49156:31;;;:37;48970:171;-1:-1:-1;48718:487:0;49243:23;;;;:43;;49271:14;49243:43;:27;:43;:::i;:::-;49217:23;;;;:69;;;;49304:14;-1:-1:-1;48355:971:0;;;:::o;1772:192::-;1858:7;1894:12;1886:6;;;;1878:29;;;;-1:-1:-1;;;1878:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;1878:29:0;-1:-1:-1;;;1930:5:0;;;1772:192::o;25691:24294::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;:::o

ipfs://10303ea9fd20399390b08bc94a184dc1cf88f1a0482efcc43e8f32e8e5ca8881