Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

//SPDX-License-Identifier: Unlicensed

pragma solidity ^0.8.4;

import "./ERC20.sol";
import "./SafeERC20.sol";
import "./SafeMath.sol";
import "./Ownable.sol";
import "./ReentrancyGuard.sol";
import "./Pausable.sol";


/**
 * @title Morphware Staking: Stake and earn rewards
 * @notice https://stake.morphware.org
 */
contract Staking is Ownable, ReentrancyGuard, Pausable {
    using SafeERC20 for IERC20;
    using SafeMath for uint256;

    event Staked(address indexed user, uint256 amount);
    event Withdawn(address indexed user, uint256 amount);

    // Token to be staked
    IERC20 public stakingToken;

    // Total amount staked
    uint256 private _totalSupply;

    address public treasury;

    uint256 public stakingEnd = 1648746000;
    // amount of rewards per token stored for each user
    // normally, this would be a fixed rate for all users
    // but with a tiered system & ability to stake multiple times during the staking period,
    // we have to calculate this differently for individual users
    mapping(address => uint256) private rewardsPerTokenStored;

    mapping(address => uint256) public userRewardPerTokenPaid;

    // last update timestamp for individual users
    mapping(address => uint256) public lastUpdateTime;

    // User balances of staked token
    mapping(address => uint256) private _balances;

    // Amount that a user has earned
    mapping(address => uint256) private rewards;

    constructor(address _stakingToken) {
        stakingToken = IERC20(_stakingToken);
        treasury = msg.sender;
    }

    modifier updateReward(address account) {
        rewardsPerTokenStored[account] = rewardPerToken(account);
        lastUpdateTime[account] = lastTimeRewardApplicable();

        rewards[account] = earned(account);
        userRewardPerTokenPaid[account] = rewardsPerTokenStored[account];
        _;
    }

    function lastTimeRewardApplicable() public view returns (uint256) {
        return block.timestamp < stakingEnd ? block.timestamp : stakingEnd;
    }

    function totalSupply() external view returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(address account) external view returns (uint256) {
        return _balances[account];
    }

    function rewardPerToken(address account) public view returns (uint) {
        if (_totalSupply == 0 || lastUpdateTime[account] == 0) {
            return 0;
        }
        return
            rewardsPerTokenStored[account] +
            ((lastTimeRewardApplicable() - lastUpdateTime[account]) * getRewardRate(_balances[account]));
    }

    function earned(address account) public view returns (uint) {
        return
            _balances[account]
            .mul(rewardPerToken(account).sub(userRewardPerTokenPaid[account]))
            .div(1e18)
            .add(rewards[account]);
    }

    function stake(uint256 amount) external nonReentrant whenNotPaused updateReward(msg.sender) {
        require(amount > 0, "STAKE MUST BE GREATER THAN 0");
        stakingToken.safeTransferFrom(msg.sender, address(this), amount);
        _totalSupply = _totalSupply.add(amount);
        _balances[msg.sender] = _balances[msg.sender].add(amount);
        emit Staked(msg.sender, amount);
    }

    function withdrawStakeAndRewards() external nonReentrant whenNotPaused updateReward(msg.sender) {
        _totalSupply = _totalSupply.sub(_balances[msg.sender]);
        (uint256 staked, uint256 accruedRewards) = calculateWithdrawal(msg.sender);
        _balances[msg.sender] = 0;
        rewards[msg.sender] = 0;
        stakingToken.safeTransfer(msg.sender, staked);
        stakingToken.safeTransferFrom(treasury, msg.sender, accruedRewards);
        emit Withdawn(msg.sender, staked +  accruedRewards);
    }

    function calculateWithdrawal(address account) internal view returns(uint256 staked, uint256 accruedRewards) {
        return (_balances[account], rewards[account]);
    }

    function getTierPercentage(uint256 balance) internal pure returns (uint256) {
        if (balance >= 1000000*1e18) return 24;
        if (balance >= 500000*1e18) return 8;
        if (balance >= 1) return 4;
        return 0;
    }

    function getRewardRate(uint256 balance) internal pure returns (uint256) {
        return getTierPercentage(balance) * 1e18/ (365 * 24 * 3600);
    }

    function pauseStaking() public onlyOwner {
        _pause();
    }

    function unpauseStaking() public onlyOwner {
        _unpause();
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Address.sol)

pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

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

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

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

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

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

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

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

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

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

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

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

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

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @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 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) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;

import "./IERC20.sol";
// import "./extensions/IERC20Metadata.sol";
import "./IERC20Metadata.sol";
// import "../../utils/Context.sol";
import "./Context.sol";

/**
 * @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 Contracts guidelines: functions revert
 * instead 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, IERC20Metadata {
    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

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

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override 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 this function is
     * overridden;
     *
     * 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 virtual override returns (uint8) {
        return 18;
    }

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

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual 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);

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
        unchecked {
            _approve(sender, _msgSender(), currentAllowance - amount);
        }

        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] + 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) {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(_msgSender(), spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * This 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);

        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[sender] = senderBalance - amount;
        }
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(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:
     *
     * - `account` 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 += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(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);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(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 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 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 {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been 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 _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

import "./IERC20.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)

pragma solidity ^0.8.0;

// import "../utils/Context.sol";
import "./Context.sol";

/**
 * @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() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual 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 {
        _transferOwnership(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");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (security/Pausable.sol)

pragma solidity ^0.8.0;

import "./Context.sol";

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        require(!paused(), "Pausable: paused");
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        require(paused(), "Pausable: not paused");
        _;
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

import "./IERC20.sol";
import "./Address.sol";

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // 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 (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @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) {
        return a + b;
    }

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

    /**
     * @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) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting 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 a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting 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) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * 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) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_stakingToken","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":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Staked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdawn","type":"event"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"earned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastTimeRewardApplicable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"lastUpdateTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pauseStaking","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"rewardPerToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stakingEnd","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakingToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","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":"treasury","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unpauseStaking","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userRewardPerTokenPaid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawStakeAndRewards","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000005f80d31044d8b15acffa3454dffda9f022453461

-----Decoded View---------------
Arg [0] : _stakingToken (address): 0x5F80D31044D8b15Acffa3454DfFDA9f022453461

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000005f80d31044d8b15acffa3454dffda9f022453461

319:4149:10:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2585:251;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2028:91;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1206:49;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;711:38;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1130:86:6;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;681:23:10;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2125:110;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1695:101:5;;;:::i;:::-;;586:26:10;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1873:149;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1092:57;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1063:85:5;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4396:70:10;;;:::i;:::-;;2842:391;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3239:512;;;:::i;:::-;;2241:338;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1945:198:5;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;4324:66:10;;;:::i;:::-;;2585:251;2639:4;2674:155;2812:7;:16;2820:7;2812:16;;;;;;;;;;;;;;;;2674:120;2789:4;2674:97;2710:60;2738:22;:31;2761:7;2738:31;;;;;;;;;;;;;;;;2710:23;2725:7;2710:14;:23::i;:::-;:27;;:60;;;;:::i;:::-;2674:9;:18;2684:7;2674:18;;;;;;;;;;;;;;;;:35;;:97;;;;:::i;:::-;:114;;:120;;;;:::i;:::-;:137;;:155;;;;:::i;:::-;2655:174;;2585:251;;;:::o;2028:91::-;2074:7;2100:12;;2093:19;;2028:91;:::o;1206:49::-;;;;;;;;;;;;;;;;;:::o;711:38::-;;;;:::o;1130:86:6:-;1177:4;1201:7;;;;;;;;;;;1194:14;;1130:86;:::o;681:23:10:-;;;;;;;;;;;;;:::o;2125:110::-;2184:7;2210:9;:18;2220:7;2210:18;;;;;;;;;;;;;;;;2203:25;;2125:110;;;:::o;1695:101:5:-;1286:12;:10;:12::i;:::-;1275:23;;:7;:5;:7::i;:::-;:23;;;1267:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;1759:30:::1;1786:1;1759:18;:30::i;:::-;1695:101::o:0;586:26:10:-;;;;;;;;;;;;;:::o;1873:149::-;1930:7;1974:10;;1956:15;:28;:59;;2005:10;;1956:59;;;1987:15;1956:59;1949:66;;1873:149;:::o;1092:57::-;;;;;;;;;;;;;;;;;:::o;1063:85:5:-;1109:7;1135:6;;;;;;;;;;;1128:13;;1063:85;:::o;4396:70:10:-;1286:12:5;:10;:12::i;:::-;1275:23;;:7;:5;:7::i;:::-;:23;;;1267:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;4449:10:10::1;:8;:10::i;:::-;4396:70::o:0;2842:391::-;1778:1:7;2376:7;;:19;;2368:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;1778:1;2509:7;:18;;;;1456:8:6::1;:6;:8::i;:::-;1455:9;1447:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;2922:10:10::2;1645:23;1660:7;1645:14;:23::i;:::-;1612:21;:30;1634:7;1612:30;;;;;;;;;;;;;;;:56;;;;1704:26;:24;:26::i;:::-;1678:14;:23;1693:7;1678:23;;;;;;;;;;;;;;;:52;;;;1760:15;1767:7;1760:6;:15::i;:::-;1741:7;:16;1749:7;1741:16;;;;;;;;;;;;;;;:34;;;;1819:21;:30;1841:7;1819:30;;;;;;;;;;;;;;;;1785:22;:31;1808:7;1785:31;;;;;;;;;;;;;;;:64;;;;2961:1:::3;2952:6;:10;2944:51;;;;;;;;;;;;:::i;:::-;;;;;;;;;3005:64;3035:10;3055:4;3062:6;3005:12;;;;;;;;;;;:29;;;;:64;;;;;;:::i;:::-;3094:24;3111:6;3094:12;;:16;;:24;;;;:::i;:::-;3079:12;:39;;;;3152:33;3178:6;3152:9;:21;3162:10;3152:21;;;;;;;;;;;;;;;;:25;;:33;;;;:::i;:::-;3128:9;:21;3138:10;3128:21;;;;;;;;;;;;;;;:57;;;;3207:10;3200:26;;;3219:6;3200:26;;;;;;:::i;:::-;;;;;;;;1496:1:6::2;1734::7::0;2688:7;:22;;;;2842:391:10;:::o;3239:512::-;1778:1:7;2376:7;;:19;;2368:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;1778:1;2509:7;:18;;;;1456:8:6::1;:6;:8::i;:::-;1455:9;1447:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;3323:10:10::2;1645:23;1660:7;1645:14;:23::i;:::-;1612:21;:30;1634:7;1612:30;;;;;;;;;;;;;;;:56;;;;1704:26;:24;:26::i;:::-;1678:14;:23;1693:7;1678:23;;;;;;;;;;;;;;;:52;;;;1760:15;1767:7;1760:6;:15::i;:::-;1741:7;:16;1749:7;1741:16;;;;;;;;;;;;;;;:34;;;;1819:21;:30;1841:7;1819:30;;;;;;;;;;;;;;;;1785:22;:31;1808:7;1785:31;;;;;;;;;;;;;;;:64;;;;3360:39:::3;3377:9;:21;3387:10;3377:21;;;;;;;;;;;;;;;;3360:12;;:16;;:39;;;;:::i;:::-;3345:12;:54;;;;3410:14;3426:22:::0;3452:31:::3;3472:10;3452:19;:31::i;:::-;3409:74;;;;3517:1;3493:9;:21;3503:10;3493:21;;;;;;;;;;;;;;;:25;;;;3550:1;3528:7;:19;3536:10;3528:19;;;;;;;;;;;;;;;:23;;;;3561:45;3587:10;3599:6;3561:12;;;;;;;;;;;:25;;;;:45;;;;;:::i;:::-;3616:67;3646:8;;;;;;;;;;;3656:10;3668:14;3616:12;;;;;;;;;;;:29;;;;:67;;;;;;:::i;:::-;3707:10;3698:46;;;3729:14;3719:6;:24;;;;:::i;:::-;3698:46;;;;;;:::i;:::-;;;;;;;;1859:1;;1496::6::2;1734::7::0;2688:7;:22;;;;3239:512:10:o;2241:338::-;2303:4;2339:1;2323:12;;:17;:49;;;;2371:1;2344:14;:23;2359:7;2344:23;;;;;;;;;;;;;;;;:28;2323:49;2319:88;;;2395:1;2388:8;;;;2319:88;2538:33;2552:9;:18;2562:7;2552:18;;;;;;;;;;;;;;;;2538:13;:33::i;:::-;2511:14;:23;2526:7;2511:23;;;;;;;;;;;;;;;;2482:26;:24;:26::i;:::-;:52;;;;:::i;:::-;2481:90;;;;:::i;:::-;2435:21;:30;2457:7;2435:30;;;;;;;;;;;;;;;;:137;;;;:::i;:::-;2416:156;;2241:338;;;;:::o;1945:198:5:-;1286:12;:10;:12::i;:::-;1275:23;;:7;:5;:7::i;:::-;:23;;;1267:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;2053:1:::1;2033:22;;:8;:22;;;;2025:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;2108:28;2127:8;2108:18;:28::i;:::-;1945:198:::0;:::o;4324:66:10:-;1286:12:5;:10;:12::i;:::-;1275:23;;:7;:5;:7::i;:::-;:23;;;1267:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;4375:8:10::1;:6;:8::i;:::-;4324:66::o:0;3214:98:9:-;3272:7;3303:1;3299;:5;;;;:::i;:::-;3292:12;;3214:98;;;;:::o;3571:::-;3629:7;3660:1;3656;:5;;;;:::i;:::-;3649:12;;3571:98;;;;:::o;3970:::-;4028:7;4059:1;4055;:5;;;;:::i;:::-;4048:12;;3970:98;;;;:::o;2833:::-;2891:7;2922:1;2918;:5;;;;:::i;:::-;2911:12;;2833:98;;;;:::o;640:96:1:-;693:7;719:10;712:17;;640:96;:::o;2297:187:5:-;2370:16;2389:6;;;;;;;;;;;2370:25;;2414:8;2405:6;;:17;;;;;;;;;;;;;;;;;;2468:8;2437:40;;2458:8;2437:40;;;;;;;;;;;;2297:187;;:::o;2189:120:6:-;1733:8;:6;:8::i;:::-;1725:41;;;;;;;;;;;;:::i;:::-;;;;;;;;;2258:5:::1;2248:7;;:15;;;;;;;;;;;;;;;;;;2279:22;2288:12;:10;:12::i;:::-;2279:22;;;;;;:::i;:::-;;;;;;;;2189:120::o:0;926:248:8:-;1070:96;1090:5;1120:27;;;1149:4;1155:2;1159:5;1097:68;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1070:19;:96::i;:::-;926:248;;;;:::o;3757:170:10:-;3825:14;3841:22;3883:9;:18;3893:7;3883:18;;;;;;;;;;;;;;;;3903:7;:16;3911:7;3903:16;;;;;;;;;;;;;;;;3875:45;;;;3757:170;;;:::o;707:211:8:-;824:86;844:5;874:23;;;899:2;903:5;851:58;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;824:19;:86::i;:::-;707:211;;;:::o;4170:148:10:-;4233:7;4295:15;4288:4;4259:26;4277:7;4259:17;:26::i;:::-;:33;;;;:::i;:::-;:52;;;;:::i;:::-;4252:59;;4170:148;;;:::o;1930:118:6:-;1456:8;:6;:8::i;:::-;1455:9;1447:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;2000:4:::1;1990:7;;:14;;;;;;;;;;;;;;;;;;2020:20;2027:12;:10;:12::i;:::-;2020:20;;;;;;:::i;:::-;;;;;;;;1930:118::o:0;3280:716:8:-;3704:23;3730:69;3758:4;3730:69;;;;;;;;;;;;;;;;;3738:5;3730:27;;;;:69;;;;;:::i;:::-;3704:95;;3834:1;3814:10;:17;:21;3810:179;;;3911:10;3900:30;;;;;;;;;;;;:::i;:::-;3892:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;3810:179;3280:716;;;:::o;3933:231:10:-;4000:7;4034:12;4023:7;:23;4019:38;;4055:2;4048:9;;;;4019:38;4082:11;4071:7;:22;4067:36;;4102:1;4095:8;;;;4067:36;4128:1;4117:7;:12;4113:26;;4138:1;4131:8;;;;4113:26;4156:1;4149:8;;3933:231;;;;:::o;3940:229:0:-;4077:12;4109:52;4131:6;4139:4;4145:1;4148:12;4109:21;:52::i;:::-;4102:59;;3940:229;;;;;:::o;5060:510::-;5230:12;5288:5;5263:21;:30;;5255:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;5355:18;5366:6;5355:10;:18::i;:::-;5347:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;5421:12;5435:23;5462:6;:11;;5481:5;5488:4;5462:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5420:73;;;;5511:51;5528:7;5537:10;5549:12;5511:16;:51::i;:::-;5504:58;;;;5060:510;;;;;;:::o;1195:326::-;1255:4;1512:1;1490:7;:19;;;:23;1483:30;;1195:326;;;:::o;7746:712::-;7896:12;7925:7;7921:530;;;7956:10;7949:17;;;;7921:530;8090:1;8070:10;:17;:21;8066:374;;;8268:10;8262:17;8329:15;8316:10;8312:2;8308:19;8301:44;8216:148;8411:12;8404:20;;;;;;;;;;;:::i;:::-;;;;;;;;7746:712;;;;;;:::o;7:139:11:-;53:5;91:6;78:20;69:29;;107:33;134:5;107:33;:::i;:::-;59:87;;;;:::o;152:137::-;206:5;237:6;231:13;222:22;;253:30;277:5;253:30;:::i;:::-;212:77;;;;:::o;295:139::-;341:5;379:6;366:20;357:29;;395:33;422:5;395:33;:::i;:::-;347:87;;;;:::o;440:262::-;499:6;548:2;536:9;527:7;523:23;519:32;516:2;;;564:1;561;554:12;516:2;607:1;632:53;677:7;668:6;657:9;653:22;632:53;:::i;:::-;622:63;;578:117;506:196;;;;:::o;708:278::-;775:6;824:2;812:9;803:7;799:23;795:32;792:2;;;840:1;837;830:12;792:2;883:1;908:61;961:7;952:6;941:9;937:22;908:61;:::i;:::-;898:71;;854:125;782:204;;;;:::o;992:262::-;1051:6;1100:2;1088:9;1079:7;1075:23;1071:32;1068:2;;;1116:1;1113;1106:12;1068:2;1159:1;1184:53;1229:7;1220:6;1209:9;1205:22;1184:53;:::i;:::-;1174:63;;1130:117;1058:196;;;;:::o;1260:118::-;1347:24;1365:5;1347:24;:::i;:::-;1342:3;1335:37;1325:53;;:::o;1384:109::-;1465:21;1480:5;1465:21;:::i;:::-;1460:3;1453:34;1443:50;;:::o;1499:373::-;1603:3;1631:38;1663:5;1631:38;:::i;:::-;1685:88;1766:6;1761:3;1685:88;:::i;:::-;1678:95;;1782:52;1827:6;1822:3;1815:4;1808:5;1804:16;1782:52;:::i;:::-;1859:6;1854:3;1850:16;1843:23;;1607:265;;;;;:::o;1878:159::-;1979:51;2024:5;1979:51;:::i;:::-;1974:3;1967:64;1957:80;;:::o;2043:364::-;2131:3;2159:39;2192:5;2159:39;:::i;:::-;2214:71;2278:6;2273:3;2214:71;:::i;:::-;2207:78;;2294:52;2339:6;2334:3;2327:4;2320:5;2316:16;2294:52;:::i;:::-;2371:29;2393:6;2371:29;:::i;:::-;2366:3;2362:39;2355:46;;2135:272;;;;;:::o;2413:366::-;2555:3;2576:67;2640:2;2635:3;2576:67;:::i;:::-;2569:74;;2652:93;2741:3;2652:93;:::i;:::-;2770:2;2765:3;2761:12;2754:19;;2559:220;;;:::o;2785:366::-;2927:3;2948:67;3012:2;3007:3;2948:67;:::i;:::-;2941:74;;3024:93;3113:3;3024:93;:::i;:::-;3142:2;3137:3;3133:12;3126:19;;2931:220;;;:::o;3157:366::-;3299:3;3320:67;3384:2;3379:3;3320:67;:::i;:::-;3313:74;;3396:93;3485:3;3396:93;:::i;:::-;3514:2;3509:3;3505:12;3498:19;;3303:220;;;:::o;3529:366::-;3671:3;3692:67;3756:2;3751:3;3692:67;:::i;:::-;3685:74;;3768:93;3857:3;3768:93;:::i;:::-;3886:2;3881:3;3877:12;3870:19;;3675:220;;;:::o;3901:366::-;4043:3;4064:67;4128:2;4123:3;4064:67;:::i;:::-;4057:74;;4140:93;4229:3;4140:93;:::i;:::-;4258:2;4253:3;4249:12;4242:19;;4047:220;;;:::o;4273:366::-;4415:3;4436:67;4500:2;4495:3;4436:67;:::i;:::-;4429:74;;4512:93;4601:3;4512:93;:::i;:::-;4630:2;4625:3;4621:12;4614:19;;4419:220;;;:::o;4645:366::-;4787:3;4808:67;4872:2;4867:3;4808:67;:::i;:::-;4801:74;;4884:93;4973:3;4884:93;:::i;:::-;5002:2;4997:3;4993:12;4986:19;;4791:220;;;:::o;5017:366::-;5159:3;5180:67;5244:2;5239:3;5180:67;:::i;:::-;5173:74;;5256:93;5345:3;5256:93;:::i;:::-;5374:2;5369:3;5365:12;5358:19;;5163:220;;;:::o;5389:366::-;5531:3;5552:67;5616:2;5611:3;5552:67;:::i;:::-;5545:74;;5628:93;5717:3;5628:93;:::i;:::-;5746:2;5741:3;5737:12;5730:19;;5535:220;;;:::o;5761:118::-;5848:24;5866:5;5848:24;:::i;:::-;5843:3;5836:37;5826:53;;:::o;5885:271::-;6015:3;6037:93;6126:3;6117:6;6037:93;:::i;:::-;6030:100;;6147:3;6140:10;;6019:137;;;;:::o;6162:222::-;6255:4;6293:2;6282:9;6278:18;6270:26;;6306:71;6374:1;6363:9;6359:17;6350:6;6306:71;:::i;:::-;6260:124;;;;:::o;6390:442::-;6539:4;6577:2;6566:9;6562:18;6554:26;;6590:71;6658:1;6647:9;6643:17;6634:6;6590:71;:::i;:::-;6671:72;6739:2;6728:9;6724:18;6715:6;6671:72;:::i;:::-;6753;6821:2;6810:9;6806:18;6797:6;6753:72;:::i;:::-;6544:288;;;;;;:::o;6838:332::-;6959:4;6997:2;6986:9;6982:18;6974:26;;7010:71;7078:1;7067:9;7063:17;7054:6;7010:71;:::i;:::-;7091:72;7159:2;7148:9;7144:18;7135:6;7091:72;:::i;:::-;6964:206;;;;;:::o;7176:210::-;7263:4;7301:2;7290:9;7286:18;7278:26;;7314:65;7376:1;7365:9;7361:17;7352:6;7314:65;:::i;:::-;7268:118;;;;:::o;7392:250::-;7499:4;7537:2;7526:9;7522:18;7514:26;;7550:85;7632:1;7621:9;7617:17;7608:6;7550:85;:::i;:::-;7504:138;;;;:::o;7648:313::-;7761:4;7799:2;7788:9;7784:18;7776:26;;7848:9;7842:4;7838:20;7834:1;7823:9;7819:17;7812:47;7876:78;7949:4;7940:6;7876:78;:::i;:::-;7868:86;;7766:195;;;;:::o;7967:419::-;8133:4;8171:2;8160:9;8156:18;8148:26;;8220:9;8214:4;8210:20;8206:1;8195:9;8191:17;8184:47;8248:131;8374:4;8248:131;:::i;:::-;8240:139;;8138:248;;;:::o;8392:419::-;8558:4;8596:2;8585:9;8581:18;8573:26;;8645:9;8639:4;8635:20;8631:1;8620:9;8616:17;8609:47;8673:131;8799:4;8673:131;:::i;:::-;8665:139;;8563:248;;;:::o;8817:419::-;8983:4;9021:2;9010:9;9006:18;8998:26;;9070:9;9064:4;9060:20;9056:1;9045:9;9041:17;9034:47;9098:131;9224:4;9098:131;:::i;:::-;9090:139;;8988:248;;;:::o;9242:419::-;9408:4;9446:2;9435:9;9431:18;9423:26;;9495:9;9489:4;9485:20;9481:1;9470:9;9466:17;9459:47;9523:131;9649:4;9523:131;:::i;:::-;9515:139;;9413:248;;;:::o;9667:419::-;9833:4;9871:2;9860:9;9856:18;9848:26;;9920:9;9914:4;9910:20;9906:1;9895:9;9891:17;9884:47;9948:131;10074:4;9948:131;:::i;:::-;9940:139;;9838:248;;;:::o;10092:419::-;10258:4;10296:2;10285:9;10281:18;10273:26;;10345:9;10339:4;10335:20;10331:1;10320:9;10316:17;10309:47;10373:131;10499:4;10373:131;:::i;:::-;10365:139;;10263:248;;;:::o;10517:419::-;10683:4;10721:2;10710:9;10706:18;10698:26;;10770:9;10764:4;10760:20;10756:1;10745:9;10741:17;10734:47;10798:131;10924:4;10798:131;:::i;:::-;10790:139;;10688:248;;;:::o;10942:419::-;11108:4;11146:2;11135:9;11131:18;11123:26;;11195:9;11189:4;11185:20;11181:1;11170:9;11166:17;11159:47;11223:131;11349:4;11223:131;:::i;:::-;11215:139;;11113:248;;;:::o;11367:419::-;11533:4;11571:2;11560:9;11556:18;11548:26;;11620:9;11614:4;11610:20;11606:1;11595:9;11591:17;11584:47;11648:131;11774:4;11648:131;:::i;:::-;11640:139;;11538:248;;;:::o;11792:222::-;11885:4;11923:2;11912:9;11908:18;11900:26;;11936:71;12004:1;11993:9;11989:17;11980:6;11936:71;:::i;:::-;11890:124;;;;:::o;12020:98::-;12071:6;12105:5;12099:12;12089:22;;12078:40;;;:::o;12124:99::-;12176:6;12210:5;12204:12;12194:22;;12183:40;;;:::o;12229:147::-;12330:11;12367:3;12352:18;;12342:34;;;;:::o;12382:169::-;12466:11;12500:6;12495:3;12488:19;12540:4;12535:3;12531:14;12516:29;;12478:73;;;;:::o;12557:305::-;12597:3;12616:20;12634:1;12616:20;:::i;:::-;12611:25;;12650:20;12668:1;12650:20;:::i;:::-;12645:25;;12804:1;12736:66;12732:74;12729:1;12726:81;12723:2;;;12810:18;;:::i;:::-;12723:2;12854:1;12851;12847:9;12840:16;;12601:261;;;;:::o;12868:185::-;12908:1;12925:20;12943:1;12925:20;:::i;:::-;12920:25;;12959:20;12977:1;12959:20;:::i;:::-;12954:25;;12998:1;12988:2;;13003:18;;:::i;:::-;12988:2;13045:1;13042;13038:9;13033:14;;12910:143;;;;:::o;13059:348::-;13099:7;13122:20;13140:1;13122:20;:::i;:::-;13117:25;;13156:20;13174:1;13156:20;:::i;:::-;13151:25;;13344:1;13276:66;13272:74;13269:1;13266:81;13261:1;13254:9;13247:17;13243:105;13240:2;;;13351:18;;:::i;:::-;13240:2;13399:1;13396;13392:9;13381:20;;13107:300;;;;:::o;13413:191::-;13453:4;13473:20;13491:1;13473:20;:::i;:::-;13468:25;;13507:20;13525:1;13507:20;:::i;:::-;13502:25;;13546:1;13543;13540:8;13537:2;;;13551:18;;:::i;:::-;13537:2;13596:1;13593;13589:9;13581:17;;13458:146;;;;:::o;13610:96::-;13647:7;13676:24;13694:5;13676:24;:::i;:::-;13665:35;;13655:51;;;:::o;13712:90::-;13746:7;13789:5;13782:13;13775:21;13764:32;;13754:48;;;:::o;13808:126::-;13845:7;13885:42;13878:5;13874:54;13863:65;;13853:81;;;:::o;13940:77::-;13977:7;14006:5;13995:16;;13985:32;;;:::o;14023:154::-;14087:9;14120:51;14165:5;14120:51;:::i;:::-;14107:64;;14097:80;;;:::o;14183:127::-;14247:9;14280:24;14298:5;14280:24;:::i;:::-;14267:37;;14257:53;;;:::o;14316:307::-;14384:1;14394:113;14408:6;14405:1;14402:13;14394:113;;;14493:1;14488:3;14484:11;14478:18;14474:1;14469:3;14465:11;14458:39;14430:2;14427:1;14423:10;14418:15;;14394:113;;;14525:6;14522:1;14519:13;14516:2;;;14605:1;14596:6;14591:3;14587:16;14580:27;14516:2;14365:258;;;;:::o;14629:180::-;14677:77;14674:1;14667:88;14774:4;14771:1;14764:15;14798:4;14795:1;14788:15;14815:180;14863:77;14860:1;14853:88;14960:4;14957:1;14950:15;14984:4;14981:1;14974:15;15001:102;15042:6;15093:2;15089:7;15084:2;15077:5;15073:14;15069:28;15059:38;;15049:54;;;:::o;15109:170::-;15249:22;15245:1;15237:6;15233:14;15226:46;15215:64;:::o;15285:225::-;15425:34;15421:1;15413:6;15409:14;15402:58;15494:8;15489:2;15481:6;15477:15;15470:33;15391:119;:::o;15516:225::-;15656:34;15652:1;15644:6;15640:14;15633:58;15725:8;15720:2;15712:6;15708:15;15701:33;15622:119;:::o;15747:166::-;15887:18;15883:1;15875:6;15871:14;15864:42;15853:60;:::o;15919:182::-;16059:34;16055:1;16047:6;16043:14;16036:58;16025:76;:::o;16107:179::-;16247:31;16243:1;16235:6;16231:14;16224:55;16213:73;:::o;16292:229::-;16432:34;16428:1;16420:6;16416:14;16409:58;16501:12;16496:2;16488:6;16484:15;16477:37;16398:123;:::o;16527:178::-;16667:30;16663:1;16655:6;16651:14;16644:54;16633:72;:::o;16711:181::-;16851:33;16847:1;16839:6;16835:14;16828:57;16817:75;:::o;16898:122::-;16971:24;16989:5;16971:24;:::i;:::-;16964:5;16961:35;16951:2;;17010:1;17007;17000:12;16951:2;16941:79;:::o;17026:116::-;17096:21;17111:5;17096:21;:::i;:::-;17089:5;17086:32;17076:2;;17132:1;17129;17122:12;17076:2;17066:76;:::o;17148:122::-;17221:24;17239:5;17221:24;:::i;:::-;17214:5;17211:35;17201:2;;17260:1;17257;17250:12;17201:2;17191:79;:::o

ipfs://dca7f27dfd883d6b1c23f51832a0e25c5897fee60aa79a569ffe7df81e25f5f0