Contract 0xe895edd6778e3c5ca6edcee4d370866e830fb799 2

/**
 *Submitted for verification at snowtrace.io on 2022-09-16
*/

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

// File @openzeppelin/contracts/access/[email protected]

// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)

pragma solidity ^0.8.0;

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

// File @openzeppelin/contracts/security/[email protected]

// OpenZeppelin Contracts v4.4.1 (security/Pausable.sol)

pragma solidity ^0.8.0;

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

// File @openzeppelin/contracts/security/[email protected]

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

// File @openzeppelin/contracts/token/ERC20/[email protected]

// OpenZeppelin Contracts (last updated v4.5.0) (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 `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, 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 `from` to `to` 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 from,
        address to,
        uint256 amount
    ) external returns (bool);

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

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

// File @openzeppelin/contracts/utils/[email protected]

// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)

pragma solidity ^0.8.1;

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

// File @openzeppelin/contracts/token/ERC20/utils/[email protected]

// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

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

// File @openzeppelin/contracts/utils/math/[email protected]

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

// File @chainlink/contracts/src/v0.8/interfaces/[email protected]

pragma solidity ^0.8.0;

interface AggregatorV3Interface {
    function decimals() external view returns (uint8);

    function description() external view returns (string memory);

    function version() external view returns (uint256);

    // getRoundData and latestRoundData should both raise "No data present"
    // if they do not have data to report, instead of returning unset values
    // which could be misinterpreted as actual reported values.
    function getRoundData(uint80 _roundId)
        external
        view
        returns (
            uint80 roundId,
            int256 answer,
            uint256 startedAt,
            uint256 updatedAt,
            uint80 answeredInRound
        );

    function latestRoundData()
        external
        view
        returns (
            uint80 roundId,
            int256 answer,
            uint256 startedAt,
            uint256 updatedAt,
            uint80 answeredInRound
        );
}

// File contracts/XZeusV2.sol

pragma solidity 0.8.16;
pragma abicoder v2;

contract XZeusV2 is Ownable, Pausable, ReentrancyGuard {
    using SafeERC20 for IERC20;
    using SafeMath for uint256;

    // Info of each user.
    struct UserInfo {
        uint256 amount; // How many staking tokens the user has provided.
        uint256 rewardDebt; // Reward debt. See explanation below.
    }

    // Info of each pool.
    struct PoolInfo {
        IERC20 stakingToken; // Address of staking token contract.
        uint256 allocPoint; // How many allocation points assigned to this pool. ZEUSs to distribute per block.
        uint256 lastRewardBlock; // Last block number that ZEUSs distribution occurs.
        uint256 accZeusPerShare; // Accumulated ZEUSs per share, times PRECISION_FACTOR. See below.
        uint256 totalShares; // Balance of total staked amount in the pool
    }

    // Info of penalty.
    struct PenaltyInfo {
        uint256 criteria; // Criteria minimum
        uint256 penalty; // Fee in usd
    }

    // Info of random number request
    struct RandomRequestInfo {
        address requester;
        uint256 poolId;
        uint256 withdrawalAmount;
    }

    // The REWARD TOKEN
    IERC20 public rewardToken;

    uint256 public rewardDecimal;

    // The REWARD HOLDER
    address public rewardHolder;

    // ZEUS token fee recipient
    address public feeRecipient;

    // ZEUS tokens created per block.
    uint256 public rewardPerBlock;

    // Bonus muliplier for early zeus makers.
    uint256 public BONUS_MULTIPLIER = 100;

    // precision factor
    uint256 public PRECISION_FACTOR = 1e12;

    // Info of each pool.
    PoolInfo[] public poolInfo;
    // Info of each pool.
    PenaltyInfo[] public penaltyInfo;

    // Info of each user that stakes staking tokens.
    mapping(uint256 => mapping(address => UserInfo)) public userInfo;
    // Total allocation poitns. Must be the sum of all allocation points in all pools.
    uint256 public totalAllocPoint = 0;

    mapping(uint256 => RandomRequestInfo) randomRequestInfo; //  => requestId => requester Info

    AggregatorV3Interface internal avaxPriceFeed;

    event Deposited(
        address indexed user,
        uint256 indexed pid,
        uint256 amount,
        uint256 rewardAmount
    );
    event Withdrawed(
        address indexed user,
        uint256 indexed pid,
        uint256 amount,
        uint256 rewardAmount
    );
    event EmergencyWithdrawed(
        address indexed user,
        uint256 indexed pid,
        uint256 amount
    );

    /**
     * @notice Constructor. Set reward token, reward emission rate and create a new pool with the params
     * @param _stakingToken  address of token of first pool
     * @param _rewardToken  address of reward token
     * @param _rewardDecimal  decimal of reward token
     * @param _rewardPerBlock  reward emission rate
     * @param _rewardHolder  address of reward holder who has enough reward tokens
     * @param _feeRecipient  address of fee recipient
     */
    constructor(
        // xStake constructor params
        IERC20 _stakingToken,
        IERC20 _rewardToken,
        uint256 _rewardDecimal,
        uint256 _rewardPerBlock,
        address _rewardHolder,
        address _feeRecipient
    ) {
        require(
            address(_stakingToken) != address(0),
            "Zero address: stakingToken"
        );
        require(
            address(_rewardToken) != address(0),
            "Zero address: rewardToken"
        );
        require(_rewardHolder != address(0), "Zero address: rewardHolder");
        require(_feeRecipient != address(0), "Zero address: feeRecipient");

        rewardToken = _rewardToken;
        rewardPerBlock = _rewardPerBlock;
        rewardDecimal = _rewardDecimal;

        // staking pool
        poolInfo.push(
            PoolInfo({
                stakingToken: _stakingToken,
                allocPoint: 1000,
                lastRewardBlock: block.number,
                accZeusPerShare: 0,
                totalShares: 0
            })
        );

        totalAllocPoint = 1000;
        rewardHolder = _rewardHolder;
        feeRecipient = _feeRecipient;

        /**
         * Network: Avalanche Mainnet
         * Aggregator: AVAX/USD
         * Address: 0x0A77230d17318075983913bC2145DB16C7366156
         */
        avaxPriceFeed = AggregatorV3Interface(
            0x0A77230d17318075983913bC2145DB16C7366156
        );
    }

    /**
     * @notice Return a length of pools
     */
    function poolLength() external view returns (uint256) {
        return poolInfo.length;
    }

    /**
     * @notice Return reward multiplier over the given _from to _to block.
     * @param _from  from block number
     * @param _to  to block number
     */
    function getMultiplier(uint256 _from, uint256 _to)
        public
        view
        returns (uint256)
    {
        return _to.sub(_from).mul(BONUS_MULTIPLIER).div(100);
    }

    /**
     * @notice Get penalty from deposit amount
     * @param _amount  amount
     */
    function getPenalty(uint256 _amount) public view returns (uint256) {
        uint256 penalty = 0;
        if (penaltyInfo.length == 0) return 0;
        if (_amount == 0) return 0;

        for (uint256 i = 0; i < penaltyInfo.length; i++) {
            if (_amount >= penaltyInfo[i].criteria) {
                penalty = penaltyInfo[i].penalty;
            } else {
                break;
            }
        }

        return penalty / (getLatestAvaxPrice() / 1e8);
    }

    /**
     * @notice View function to see pending Reward on frontend.
     * @param _pid  pool id
     * @param _user  user address
     */
    function pendingReward(uint256 _pid, address _user)
        external
        view
        returns (uint256)
    {
        PoolInfo memory pool = poolInfo[_pid];
        UserInfo memory user = userInfo[_pid][_user];
        uint256 accZeusPerShare = pool.accZeusPerShare;
        uint256 stakingTokenSupply = pool.totalShares;
        if (block.number > pool.lastRewardBlock && stakingTokenSupply != 0) {
            uint256 multiplier = getMultiplier(
                pool.lastRewardBlock,
                block.number
            );
            uint256 usdcReward = multiplier
                .mul(rewardPerBlock)
                .mul(pool.allocPoint)
                .div(totalAllocPoint);
            accZeusPerShare = accZeusPerShare.add(
                (usdcReward.mul(PRECISION_FACTOR).div(stakingTokenSupply))
            );
        }
        return
            user
                .amount
                .mul(accZeusPerShare)
                .div(PRECISION_FACTOR)
                .mul(10**rewardDecimal)
                .div(1e18)
                .sub(user.rewardDebt);
    }

    /**
     * @notice Add a new stakingToken to the pool. Can only be called by the owner.
     * XXX DO NOT add the same staking token more than once. Rewards will be messed up if you do.
     * @param _allocPoint  reward allocation point
     * @param _stakingToken  token address
     */
    function add(uint256 _allocPoint, IERC20 _stakingToken)
        public
        onlyOwner
        whenNotPaused
    {
        require(
            address(_stakingToken) != address(0),
            "Staking token: Zero address"
        );
        for (uint256 i = 0; i < poolInfo.length; i++) {
            if (address(poolInfo[i].stakingToken) == address(_stakingToken))
                revert("Pool duplicated");
        }

        massUpdatePools();
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolInfo.push(
            PoolInfo({
                stakingToken: _stakingToken,
                allocPoint: _allocPoint,
                lastRewardBlock: block.number,
                accZeusPerShare: 0,
                totalShares: 0
            })
        );
    }

    /**
     * @notice Update the given pool's ZEUS allocation point. Can only be called by the owner.
     * @param _pid  pool id
     * @param _allocPoint  reward allocation point
     */
    function set(uint256 _pid, uint256 _allocPoint)
        public
        onlyOwner
        whenNotPaused
    {
        massUpdatePools();
        uint256 prevAllocPoint = poolInfo[_pid].allocPoint;
        poolInfo[_pid].allocPoint = _allocPoint;
        if (prevAllocPoint != _allocPoint) {
            totalAllocPoint = totalAllocPoint.sub(prevAllocPoint).add(
                _allocPoint
            );
        }
    }

    /**
     * @notice Update multiplier. Can only be called by the owner.
     * @param _multiplierNumber  _multiplier value
     */
    function updateMultiplier(uint256 _multiplierNumber) public onlyOwner {
        require(_multiplierNumber >= 100, "Invalid multipler number");
        BONUS_MULTIPLIER = _multiplierNumber;
    }

    /**
     * @notice Add penalty info
     * @param _criteria  penalty criteria amount
     * @param _penalty  penalty point
     */
    function addPenaltyInfo(uint256 _criteria, uint256 _penalty)
        public
        whenNotPaused
        onlyOwner
    {
        uint256 penaltyLength = penaltyInfo.length;
        if (penaltyLength == 0) {
            penaltyInfo.push(
                PenaltyInfo({criteria: _criteria, penalty: _penalty})
            );
        } else {
            require(
                _criteria > penaltyInfo[penaltyLength - 1].criteria,
                "Criteria error: < last criteria"
            );

            penaltyInfo.push(
                PenaltyInfo({criteria: _criteria, penalty: _penalty})
            );
        }
    }

    /**
     * @notice Update penalty info
     * @param _criteria  penalty criteria amount
     * @param _penalty  penalty point
     */
    function updatePenaltyInfo(uint256 _criteria, uint256 _penalty)
        public
        whenNotPaused
        onlyOwner
    {
        bool isUpdated;
        for (uint256 index = 0; index < penaltyInfo.length; index++) {
            if (penaltyInfo[index].criteria == _criteria) {
                penaltyInfo[index].penalty = _penalty;
                isUpdated = true;
                break;
            }
        }
        if (!isUpdated) revert("Criteria is not matched");
    }

    /**
     * @notice Update reward holder
     * @param _rewardHolder  address of reward holder who has enough reward tokens
     */
    function setRewardHolder(address _rewardHolder)
        public
        onlyOwner
        whenNotPaused
    {
        require(_rewardHolder != address(0), "Zero address: rewardHolder");
        rewardHolder = _rewardHolder;
    }

    /**
     * @notice Update fee recipient
     * @param _feeRecipient  address of fee recipient
     */
    function setFeeRecipient(address _feeRecipient)
        public
        onlyOwner
        whenNotPaused
    {
        require(_feeRecipient != address(0), "Zero address: feeRecipient");
        feeRecipient = _feeRecipient;
    }

    /**
     * @notice Update reward emission rate
     * @param _rewardPerBlock  reward emission rate
     */
    function setRewardPerBlock(uint256 _rewardPerBlock)
        public
        onlyOwner
        whenNotPaused
    {
        rewardPerBlock = _rewardPerBlock;
    }

    /**
     * @notice Update reward variables of the given pool to be up-to-date.
     * @param _pid  pool id
     */
    function updatePool(uint256 _pid) public whenNotPaused {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.number <= pool.lastRewardBlock) {
            return;
        }
        uint256 stakingTokenSupply = pool.totalShares;
        if (stakingTokenSupply == 0) {
            pool.lastRewardBlock = block.number;
            return;
        }
        uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
        uint256 usdcReward = multiplier
            .mul(rewardPerBlock)
            .mul(pool.allocPoint)
            .div(totalAllocPoint);
        pool.accZeusPerShare = pool.accZeusPerShare.add(
            usdcReward.mul(PRECISION_FACTOR).div(stakingTokenSupply)
        );
        pool.lastRewardBlock = block.number;
    }

    /**
     * @notice Update reward variables for all pools
     */
    function massUpdatePools() public whenNotPaused {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            updatePool(pid);
        }
    }

    /**
     * @notice Deposit tokens
     * @param _pid  pool id
     * @param _amount  token amount
     */
    function deposit(uint256 _pid, uint256 _amount)
        public
        payable
        whenNotPaused
    {
        require(_amount != 0, "Amount should be greater than 0");
        require(_pid < poolInfo.length, "Pool is not existed");

        uint256 feeAmount = getPenalty(_amount);
        require(msg.value >= feeAmount, "Insufficient AVAX balance");

        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];

        updatePool(_pid);
        uint256 pending;
        if (user.amount > 0) {
            pending = user
                .amount
                .mul(pool.accZeusPerShare)
                .div(PRECISION_FACTOR)
                .mul(10**rewardDecimal)
                .div(1e18)
                .sub(user.rewardDebt);
            if (pending > 0) {
                rewardToken.safeTransferFrom(rewardHolder, msg.sender, pending);
            }
        }

        // get penalty in avax
        pool.stakingToken.safeTransferFrom(msg.sender, address(this), _amount);
        pool.totalShares += _amount;
        user.amount = user.amount.add(_amount);
        user.rewardDebt = user
            .amount
            .mul(pool.accZeusPerShare)
            .div(PRECISION_FACTOR)
            .mul(10**rewardDecimal)
            .div(1e18);

        // transfer avax fee to feeRecipient
        payable(feeRecipient).transfer(feeAmount);

        emit Deposited(msg.sender, _pid, _amount, pending);
    }

    /**
     * @notice Withdraw tokens
     * @param _pid  pool id
     * @param _amount  token amount
     */
    function withdraw(uint256 _pid, uint256 _amount)
        public
        nonReentrant
        whenNotPaused
    {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];

        require(user.amount >= _amount, "withdraw: not good");

        updatePool(_pid);

        uint256 pending = user
            .amount
            .mul(pool.accZeusPerShare)
            .div(PRECISION_FACTOR)
            .mul(10**rewardDecimal)
            .div(1e18)
            .sub(user.rewardDebt);

        if (pending > 0) {
            rewardToken.safeTransferFrom(rewardHolder, msg.sender, pending);
        }

        if (_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.stakingToken.safeTransfer(msg.sender, _amount);
            pool.totalShares -= _amount;
        }

        user.rewardDebt = user
            .amount
            .mul(pool.accZeusPerShare)
            .div(PRECISION_FACTOR)
            .mul(10**rewardDecimal)
            .div(1e18);

        emit Withdrawed(msg.sender, _pid, _amount, pending);
    }

    /**
     * @notice Withdraw without caring about rewards. EMERGENCY ONLY.
     * @param _pid  pool id
     */
    function emergencyWithdraw(uint256 _pid) public whenNotPaused {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];

        pool.stakingToken.safeTransfer(address(msg.sender), user.amount);
        pool.totalShares -= user.amount;
        emit EmergencyWithdrawed(msg.sender, _pid, user.amount);

        user.amount = 0;
        user.rewardDebt = 0;
    }

    /**
     * @notice Get latest AVAX price
     */
    function getLatestAvaxPrice() public view returns (uint256) {
        (, int256 price, , , ) = avaxPriceFeed.latestRoundData();
        return uint256(price);
    }
}

[{"inputs":[{"internalType":"contract IERC20","name":"_stakingToken","type":"address"},{"internalType":"contract IERC20","name":"_rewardToken","type":"address"},{"internalType":"uint256","name":"_rewardDecimal","type":"uint256"},{"internalType":"uint256","name":"_rewardPerBlock","type":"uint256"},{"internalType":"address","name":"_rewardHolder","type":"address"},{"internalType":"address","name":"_feeRecipient","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"rewardAmount","type":"uint256"}],"name":"Deposited","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdrawed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","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":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"rewardAmount","type":"uint256"}],"name":"Withdrawed","type":"event"},{"inputs":[],"name":"BONUS_MULTIPLIER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PRECISION_FACTOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IERC20","name":"_stakingToken","type":"address"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_criteria","type":"uint256"},{"internalType":"uint256","name":"_penalty","type":"uint256"}],"name":"addPenaltyInfo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeRecipient","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getLatestAvaxPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_from","type":"uint256"},{"internalType":"uint256","name":"_to","type":"uint256"}],"name":"getMultiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"getPenalty","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"penaltyInfo","outputs":[{"internalType":"uint256","name":"criteria","type":"uint256"},{"internalType":"uint256","name":"penalty","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"stakingToken","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardBlock","type":"uint256"},{"internalType":"uint256","name":"accZeusPerShare","type":"uint256"},{"internalType":"uint256","name":"totalShares","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardDecimal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardHolder","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeRecipient","type":"address"}],"name":"setFeeRecipient","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_rewardHolder","type":"address"}],"name":"setRewardHolder","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_rewardPerBlock","type":"uint256"}],"name":"setRewardPerBlock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalAllocPoint","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":[{"internalType":"uint256","name":"_multiplierNumber","type":"uint256"}],"name":"updateMultiplier","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_criteria","type":"uint256"},{"internalType":"uint256","name":"_penalty","type":"uint256"}],"name":"updatePenaltyInfo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000008c3633ee619a42d3755327c2524e4d108838c47f000000000000000000000000b97ef9ef8734c71904d8002f8b6bc66dd9c48a6e000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000b8bdb9785200000000000000000000000000000a4172f0dc120bf4a0f0750e52a9a5652fd6de4b0000000000000000000000000a4172f0dc120bf4a0f0750e52a9a5652fd6de4b

-----Decoded View---------------
Arg [0] : _stakingToken (address): 0x8c3633ee619a42d3755327c2524e4d108838c47f
Arg [1] : _rewardToken (address): 0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e
Arg [2] : _rewardDecimal (uint256): 6
Arg [3] : _rewardPerBlock (uint256): 52000000000000000
Arg [4] : _rewardHolder (address): 0x0a4172f0dc120bf4a0f0750e52a9a5652fd6de4b
Arg [5] : _feeRecipient (address): 0x0a4172f0dc120bf4a0f0750e52a9a5652fd6de4b

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 0000000000000000000000008c3633ee619a42d3755327c2524e4d108838c47f
Arg [1] : 000000000000000000000000b97ef9ef8734c71904d8002f8b6bc66dd9c48a6e
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000006
Arg [3] : 00000000000000000000000000000000000000000000000000b8bdb978520000
Arg [4] : 0000000000000000000000000a4172f0dc120bf4a0f0750e52a9a5652fd6de4b
Arg [5] : 0000000000000000000000000a4172f0dc120bf4a0f0750e52a9a5652fd6de4b

33286:16351:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34992:32;;;;;;;;;;-1:-1:-1;34992:32:0;;;;;:::i;:::-;;:::i;:::-;;;;373:25:1;;;429:2;414:18;;407:34;;;;346:18;34992:32:0;;;;;;;;37885:95;;;;;;;;;;-1:-1:-1;37957:8:0;:15;37885:95;;;598:25:1;;;586:2;571:18;37885:95:0;452:177:1;34932:26:0;;;;;;;;;;-1:-1:-1;34932:26:0;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;925:32:1;;;907:51;;989:2;974:18;;967:34;;;;1017:18;;;1010:34;;;;1075:2;1060:18;;1053:34;1118:3;1103:19;;1096:35;894:3;879:19;34932:26:0;634:503:1;35246:34:0;;;;;;;;;;;;;;;;41529:432;;;;;;;;;;-1:-1:-1;41529:432:0;;;;;:::i;:::-;;:::i;:::-;;40513:813;;;;;;;;;;-1:-1:-1;40513:813:0;;;;;:::i;:::-;;:::i;49467:167::-;;;;;;;;;;;;;:::i;47720:1134::-;;;;;;;;;;-1:-1:-1;47720:1134:0;;;;;:::i;:::-;;:::i;34627:27::-;;;;;;;;;;-1:-1:-1;34627:27:0;;;;-1:-1:-1;;;;;34627:27:0;;;;;;-1:-1:-1;;;;;2045:32:1;;;2027:51;;2015:2;2000:18;34627:27:0;1881:203:1;34495:28:0;;;;;;;;;;;;;;;;44898:788;;;;;;;;;;-1:-1:-1;44898:788:0;;;;;:::i;:::-;;:::i;48980:423::-;;;;;;;;;;-1:-1:-1;48980:423:0;;;;;:::i;:::-;;:::i;34558:27::-;;;;;;;;;;-1:-1:-1;34558:27:0;;;;-1:-1:-1;;;;;34558:27:0;;;4598:86;;;;;;;;;;-1:-1:-1;4645:4:0;4669:7;-1:-1:-1;;;4669:7:0;;;;4598:86;;2254:14:1;;2247:22;2229:41;;2217:2;2202:18;4598:86:0;2089:187:1;42107:197:0;;;;;;;;;;-1:-1:-1;42107:197:0;;;;;:::i;:::-;;:::i;45766:194::-;;;;;;;;;;;;;:::i;43890:235::-;;;;;;;;;;-1:-1:-1;43890:235:0;;;;;:::i;:::-;;:::i;42452:646::-;;;;;;;;;;-1:-1:-1;42452:646:0;;;;;:::i;:::-;;:::i;2610:103::-;;;;;;;;;;;;;:::i;34787:37::-;;;;;;;;;;;;;;;;34702:29;;;;;;;;;;;;;;;;1959:87;;;;;;;;;;-1:-1:-1;2005:7:0;2032:6;-1:-1:-1;;;;;2032:6:0;1959:87;;38158:184;;;;;;;;;;-1:-1:-1;38158:184:0;;;;;:::i;:::-;;:::i;35087:64::-;;;;;;;;;;-1:-1:-1;35087:64:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38447:488;;;;;;;;;;-1:-1:-1;38447:488:0;;;;;:::i;:::-;;:::i;39090:1117::-;;;;;;;;;;-1:-1:-1;39090:1117:0;;;;;:::i;:::-;;:::i;44601:166::-;;;;;;;;;;-1:-1:-1;44601:166:0;;;;;:::i;:::-;;:::i;34858:38::-;;;;;;;;;;;;;;;;43249:494;;;;;;;;;;-1:-1:-1;43249:494:0;;;;;:::i;:::-;;:::i;46083:1513::-;;;;;;:::i;:::-;;:::i;44243:235::-;;;;;;;;;;-1:-1:-1;44243:235:0;;;;;:::i;:::-;;:::i;2868:238::-;;;;;;;;;;-1:-1:-1;2868:238:0;;;;;:::i;:::-;;:::i;34461:25::-;;;;;;;;;;-1:-1:-1;34461:25:0;;;;-1:-1:-1;;;;;34461:25:0;;;34992:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;34992:32:0;:::o;34932:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;34932:26:0;;;;-1:-1:-1;34932:26:0;;;;;:::o;41529:432::-;2005:7;2032:6;-1:-1:-1;;;;;2032:6:0;736:10;2179:23;2171:68;;;;-1:-1:-1;;;2171:68:0;;;;;;;:::i;:::-;;;;;;;;;4645:4;4669:7;-1:-1:-1;;;4669:7:0;;;;4923:9:::1;4915:38;;;;-1:-1:-1::0;;;4915:38:0::1;;;;;;;:::i;:::-;41651:17:::2;:15;:17::i;:::-;41679:22;41704:8;41713:4;41704:14;;;;;;;;:::i;:::-;;;;;;;;;;;:25;;;41679:50;;41768:11;41740:8;41749:4;41740:14;;;;;;;;:::i;:::-;;;;;;;;;;;:25;;:39;;;;41812:11;41794:14;:29;41790:164;;41858:84;41916:11;41858:35;41878:14;41858:15;;:19;;:35;;;;:::i;:::-;:39:::0;::::2;:84::i;:::-;41840:15;:102:::0;41790:164:::2;41640:321;41529:432:::0;;:::o;40513:813::-;2005:7;2032:6;-1:-1:-1;;;;;2032:6:0;736:10;2179:23;2171:68;;;;-1:-1:-1;;;2171:68:0;;;;;;;:::i;:::-;4645:4;4669:7;-1:-1:-1;;;4669:7:0;;;;4923:9:::1;4915:38;;;;-1:-1:-1::0;;;4915:38:0::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;40665:36:0;::::2;40643:113;;;::::0;-1:-1:-1;;;40643:113:0;;4131:2:1;40643:113:0::2;::::0;::::2;4113:21:1::0;4170:2;4150:18;;;4143:30;4209:29;4189:18;;;4182:57;4256:18;;40643:113:0::2;3929:351:1::0;40643:113:0::2;40772:9;40767:180;40791:8;:15:::0;40787:19;::::2;40767:180;;;40877:13;-1:-1:-1::0;;;;;40832:59:0::2;40840:8;40849:1;40840:11;;;;;;;;:::i;:::-;;::::0;;;::::2;::::0;;;::::2;::::0;;::::2;;:24:::0;-1:-1:-1;;;;;40840:24:0::2;40832:59:::0;40828:107:::2;;40910:25;::::0;-1:-1:-1;;;40910:25:0;;4487:2:1;40910:25:0::2;::::0;::::2;4469:21:1::0;4526:2;4506:18;;;4499:30;-1:-1:-1;;;4545:18:1;;;4538:45;4600:18;;40910:25:0::2;4285:339:1::0;40828:107:0::2;40808:3:::0;::::2;::::0;::::2;:::i;:::-;;;;40767:180;;;;40959:17;:15;:17::i;:::-;41005:15;::::0;:32:::2;::::0;41025:11;41005:19:::2;:32::i;:::-;40987:15;:50:::0;41076:231:::2;::::0;;::::2;::::0;::::2;::::0;;-1:-1:-1;;;;;41076:231:0;;::::2;::::0;;::::2;::::0;::::2;::::0;;;41209:12:::2;41076:231:::0;;;;;;-1:-1:-1;41076:231:0;;;;;;;;;;;;41048:8:::2;:270:::0;;::::2;::::0;::::2;::::0;;;;;;;::::2;::::0;;::::2;::::0;;::::2;::::0;;-1:-1:-1;;;;;;41048:270:0::2;::::0;;;::::2;;::::0;;;;;;;;;;;;;;;;;;;;;;;;;;;40513:813::o;49467:167::-;49518:7;49541:12;49563:13;;;;;;;;;-1:-1:-1;;;;;49563:13:0;-1:-1:-1;;;;;49563:29:0;;:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;49538:56:0;;49467:167;-1:-1:-1;;;;;49467:167:0:o;47720:1134::-;7600:1;8198:7;;:19;8190:63;;;;-1:-1:-1;;;8190:63:0;;5765:2:1;8190:63:0;;;5747:21:1;5804:2;5784:18;;;5777:30;5843:33;5823:18;;;5816:61;5894:18;;8190:63:0;5563:355:1;8190:63:0;7600:1;8331:7;:18;4645:4;4669:7;-1:-1:-1;;;4669:7:0;;;;4923:9:::1;4915:38;;;;-1:-1:-1::0;;;4915:38:0::1;;;;;;;:::i;:::-;47846:21:::2;47870:8;47879:4;47870:14;;;;;;;;:::i;:::-;;::::0;;;::::2;::::0;;;47919;;;:8:::2;:14:::0;;;;;;47934:10:::2;47919:26:::0;;;;;;;47966:11;;47870:14:::2;::::0;;::::2;::::0;;::::2;::::0;-1:-1:-1;47966:22:0;-1:-1:-1;47966:22:0::2;47958:53;;;::::0;-1:-1:-1;;;47958:53:0;;6125:2:1;47958:53:0::2;::::0;::::2;6107:21:1::0;6164:2;6144:18;;;6137:30;-1:-1:-1;;;6183:18:1;;;6176:48;6241:18;;47958:53:0::2;5923:342:1::0;47958:53:0::2;48024:16;48035:4;48024:10;:16::i;:::-;48053:15;48071:197;48252:4;:15;;;48071:162;48228:4;48071:138;48195:13;;48191:2;:17;;;;:::i;:::-;48155:16;::::0;48115:20:::2;::::0;::::2;::::0;48071:25;;:101:::2;::::0;48155:16;48071:65:::2;::::0;:25;:43:::2;:65::i;:::-;:83:::0;::::2;:101::i;:::-;:119:::0;::::2;:138::i;:162::-;:180:::0;::::2;:197::i;:::-;48053:215:::0;-1:-1:-1;48285:11:0;;48281:107:::2;;48342:12;::::0;48313:11:::2;::::0;:63:::2;::::0;-1:-1:-1;;;;;48313:11:0;;::::2;::::0;48342:12:::2;48356:10;48368:7:::0;48313:28:::2;:63::i;:::-;48404:11:::0;;48400:190:::2;;48446:11:::0;;:24:::2;::::0;48462:7;48446:15:::2;:24::i;:::-;48432:38:::0;;48485:17;;:51:::2;::::0;-1:-1:-1;;;;;48485:17:0::2;48516:10;48528:7:::0;48485:30:::2;:51::i;:::-;48571:7;48551:4;:16;;;:27;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;48400:190:0::2;48620:162;48777:4;48620:138;48744:13;;48740:2;:17;;;;:::i;:::-;48704:16;::::0;48664:20:::2;::::0;::::2;::::0;48620:25;;:101:::2;::::0;48704:16;48620:65:::2;::::0;:25;:43:::2;:65::i;:162::-;48602:15;::::0;::::2;:180:::0;48800:46:::2;::::0;;373:25:1;;;429:2;414:18;;407:34;;;48823:4:0;;48811:10:::2;::::0;48800:46:::2;::::0;346:18:1;48800:46:0::2;;;;;;;-1:-1:-1::0;;7556:1:0;8510:22;;-1:-1:-1;;;47720:1134:0:o;44898:788::-;4645:4;4669:7;-1:-1:-1;;;4669:7:0;;;;4923:9;4915:38;;;;-1:-1:-1;;;4915:38:0;;;;;;;:::i;:::-;44964:21:::1;44988:8;44997:4;44988:14;;;;;;;;:::i;:::-;;;;;;;;;;;44964:38;;45033:4;:20;;;45017:12;:36;45013:75;;45070:7;44898:788:::0;:::o;45013:75::-:1;45127:16;::::0;::::1;::::0;45098:26:::1;45158:23:::0;;;45154:112:::1;;-1:-1:-1::0;45221:12:0::1;45198:20;::::0;;::::1;:35:::0;44898:788;:::o;45154:112::-:1;45276:18;45297:49;45311:4;:20;;;45333:12;45297:13;:49::i;:::-;45276:70;;45357:18;45378:114;45476:15;;45378:79;45441:4;:15;;;45378:44;45407:14;;45378:10;:28;;:44;;;;:::i;:114::-;45357:135;;45526:106;45565:56;45602:18;45565:32;45580:16;;45565:10;:14;;:32;;;;:::i;:56::-;45526:20;::::0;::::1;::::0;;:24:::1;:106::i;:::-;45503:20;::::0;::::1;:129:::0;-1:-1:-1;;45666:12:0::1;45643:20;::::0;;::::1;:35:::0;;;;-1:-1:-1;4964:1:0::1;44898:788:::0;:::o;48980:423::-;4645:4;4669:7;-1:-1:-1;;;4669:7:0;;;;4923:9;4915:38;;;;-1:-1:-1;;;4915:38:0;;;;;;;:::i;:::-;49053:21:::1;49077:8;49086:4;49077:14;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;49126;;;:8:::1;:14:::0;;;;;;49141:10:::1;49126:26:::0;;;;;;;;49217:11;;49077:14:::1;::::0;;::::1;::::0;;::::1;49165:17:::0;;49077:14;;-1:-1:-1;49165:64:0::1;::::0;-1:-1:-1;;;;;49165:17:0;;;::::1;::::0;49141:10;49165:30:::1;:64::i;:::-;49260:11:::0;;49240:16:::1;::::0;::::1;:31:::0;;49260:11:::1;::::0;49240:31:::1;::::0;49260:11;;49240:31:::1;:::i;:::-;::::0;;;-1:-1:-1;;49325:11:0;;49287:50:::1;::::0;598:25:1;;;49319:4:0;;49307:10:::1;::::0;49287:50:::1;::::0;586:2:1;571:18;49287:50:0::1;;;;;;;49364:1;49350:15:::0;;;49376::::1;::::0;;::::1;:19:::0;-1:-1:-1;;48980:423:0:o;42107:197::-;2005:7;2032:6;-1:-1:-1;;;;;2032:6:0;736:10;2179:23;2171:68;;;;-1:-1:-1;;;2171:68:0;;;;;;;:::i;:::-;42217:3:::1;42196:17;:24;;42188:61;;;::::0;-1:-1:-1;;;42188:61:0;;7979:2:1;42188:61:0::1;::::0;::::1;7961:21:1::0;8018:2;7998:18;;;7991:30;8057:26;8037:18;;;8030:54;8101:18;;42188:61:0::1;7777:348:1::0;42188:61:0::1;42260:16;:36:::0;42107:197::o;45766:194::-;4645:4;4669:7;-1:-1:-1;;;4669:7:0;;;;4923:9;4915:38;;;;-1:-1:-1;;;4915:38:0;;;;;;;:::i;:::-;45842:8:::1;:15:::0;45825:14:::1;45868:85;45896:6;45890:3;:12;45868:85;;;45926:15;45937:3;45926:10;:15::i;:::-;45904:5;::::0;::::1;:::i;:::-;;;45868:85;;;;45814:146;45766:194::o:0;43890:235::-;2005:7;2032:6;-1:-1:-1;;;;;2032:6:0;736:10;2179:23;2171:68;;;;-1:-1:-1;;;2171:68:0;;;;;;;:::i;:::-;4645:4;4669:7;-1:-1:-1;;;4669:7:0;;;;4923:9:::1;4915:38;;;;-1:-1:-1::0;;;4915:38:0::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;44020:27:0;::::2;44012:66;;;::::0;-1:-1:-1;;;44012:66:0;;8332:2:1;44012:66:0::2;::::0;::::2;8314:21:1::0;8371:2;8351:18;;;8344:30;8410:28;8390:18;;;8383:56;8456:18;;44012:66:0::2;8130:350:1::0;44012:66:0::2;44089:12;:28:::0;;-1:-1:-1;;;;;;44089:28:0::2;-1:-1:-1::0;;;;;44089:28:0;;;::::2;::::0;;;::::2;::::0;;43890:235::o;42452:646::-;4645:4;4669:7;-1:-1:-1;;;4669:7:0;;;;4923:9;4915:38;;;;-1:-1:-1;;;4915:38:0;;;;;;;:::i;:::-;2005:7;2032:6;-1:-1:-1;;;;;2032:6:0;736:10;2179:23:::1;2171:68;;;;-1:-1:-1::0;;;2171:68:0::1;;;;;;;:::i;:::-;42611:11:::2;:18:::0;42587:21:::2;42644:18:::0;;;42640:451:::2;;-1:-1:-1::0;42714:53:0::2;::::0;;;;::::2;::::0;;;;;;::::2;::::0;::::2;::::0;;;42679:11:::2;:103:::0;;::::2;::::0;::::2;::::0;;-1:-1:-1;42679:103:0;;;;;;;::::2;::::0;;::::2;::::0;;::::2;::::0;;;;;;;41529:432::o;42640:451::-:2;42853:11;42865:17;42881:1;42865:13:::0;:17:::2;:::i;:::-;42853:30;;;;;;;;:::i;:::-;;;;;;;;;;;:39;;;42841:9;:51;42815:144;;;::::0;-1:-1:-1;;;42815:144:0;;8687:2:1;42815:144:0::2;::::0;::::2;8669:21:1::0;8726:2;8706:18;;;8699:30;8765:33;8745:18;;;8738:61;8816:18;;42815:144:0::2;8485:355:1::0;42815:144:0::2;-1:-1:-1::0;43011:53:0::2;::::0;;;;::::2;::::0;;;;;;::::2;::::0;::::2;::::0;;;42976:11:::2;:103:::0;;::::2;::::0;::::2;::::0;;-1:-1:-1;42976:103:0;;;;;;;::::2;::::0;;::::2;::::0;;::::2;::::0;;;;;;;42452:646::o;2610:103::-;2005:7;2032:6;-1:-1:-1;;;;;2032:6:0;736:10;2179:23;2171:68;;;;-1:-1:-1;;;2171:68:0;;;;;;;:::i;:::-;2675:30:::1;2702:1;2675:18;:30::i;:::-;2610:103::o:0;38158:184::-;38257:7;38289:45;38330:3;38289:36;38308:16;;38289:14;38297:5;38289:3;:7;;:14;;;;:::i;:45::-;38282:52;;38158:184;;;;;:::o;38447:488::-;38559:11;:18;38505:7;;;;38559:23;;38555:37;;-1:-1:-1;38591:1:0;;38447:488;-1:-1:-1;;38447:488:0:o;38555:37::-;38607:7;38618:1;38607:12;38603:26;;-1:-1:-1;38628:1:0;;38447:488;-1:-1:-1;;38447:488:0:o;38603:26::-;38647:9;38642:228;38666:11;:18;38662:22;;38642:228;;;38721:11;38733:1;38721:14;;;;;;;;:::i;:::-;;;;;;;;;;;:23;;;38710:7;:34;38706:153;;38775:11;38787:1;38775:14;;;;;;;;:::i;:::-;;;;;;;;;;;:22;;;38765:32;;38706:153;;;38838:5;;38706:153;38686:3;;;;:::i;:::-;;;;38642:228;;;;38923:3;38900:20;:18;:20::i;:::-;:26;;;;:::i;:::-;38889:38;;:7;:38;:::i;:::-;38882:45;38447:488;-1:-1:-1;;;38447:488:0:o;39090:1117::-;39192:7;39217:20;39240:8;39249:4;39240:14;;;;;;;;:::i;:::-;;;;;;;;;39217:37;;;;;;;;39240:14;;;;;;;39217:37;;-1:-1:-1;;;;;39217:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39288:14;;;:8;:14;;;;;:21;;;;;;;;;;;;39265:44;;;;;;;;;;;;;;;;;;;;;39346:20;39406:16;;39452:20;;39217:37;;-1:-1:-1;39265:44:0;39346:20;;39437:12;:35;:62;;;;-1:-1:-1;39476:23:0;;;39437:62;39433:520;;;39516:18;39537:98;39569:4;:20;;;39608:12;39537:13;:98::i;:::-;39516:119;;39650:18;39671:126;39781:15;;39671:87;39742:4;:15;;;39671:48;39704:14;;39671:10;:32;;:48;;;;:::i;:126::-;39650:147;;39830:111;39869:56;39906:18;39869:32;39884:16;;39869:10;:14;;:32;;;;:::i;:56::-;39830:15;;:19;:111::i;:::-;39812:129;;39501:452;;39433:520;39983:216;40183:4;:15;;;39983:177;40155:4;39983:149;40118:13;;40114:2;:17;;;;:::i;:::-;40074:16;;39983:29;;:108;;40074:16;39983:68;;40035:15;39983:51;:68::i;:216::-;39963:236;39090:1117;-1:-1:-1;;;;;;;39090:1117:0:o;44601:166::-;2005:7;2032:6;-1:-1:-1;;;;;2032:6:0;736:10;2179:23;2171:68;;;;-1:-1:-1;;;2171:68:0;;;;;;;:::i;:::-;4645:4;4669:7;-1:-1:-1;;;4669:7:0;;;;4923:9:::1;4915:38;;;;-1:-1:-1::0;;;4915:38:0::1;;;;;;;:::i;:::-;44727:14:::2;:32:::0;44601:166::o;43249:494::-;4645:4;4669:7;-1:-1:-1;;;4669:7:0;;;;4923:9;4915:38;;;;-1:-1:-1;;;4915:38:0;;;;;;;:::i;:::-;2005:7;2032:6;-1:-1:-1;;;;;2032:6:0;736:10;2179:23:::1;2171:68;;;;-1:-1:-1::0;;;2171:68:0::1;;;;;;;:::i;:::-;43387:14:::2;::::0;43412:264:::2;43444:11;:18:::0;43436:26;::::2;43412:264;;;43523:9;43492:11;43504:5;43492:18;;;;;;;;:::i;:::-;;;;;;;;;;;:27;;;:40:::0;43488:177:::2;;43582:8;43553:11;43565:5;43553:18;;;;;;;;:::i;:::-;;;;;;;;;;;:26;;:37;;;;43621:4;43609:16;;43644:5;;43488:177;43464:7:::0;::::2;::::0;::::2;:::i;:::-;;;;43412:264;;;;43691:9;43686:49;;43702:33;::::0;-1:-1:-1;;;43702:33:0;;9269:2:1;43702:33:0::2;::::0;::::2;9251:21:1::0;9308:2;9288:18;;;9281:30;9347:25;9327:18;;;9320:53;9390:18;;43702:33:0::2;9067:347:1::0;46083:1513:0;4645:4;4669:7;-1:-1:-1;;;4669:7:0;;;;4923:9;4915:38;;;;-1:-1:-1;;;4915:38:0;;;;;;;:::i;:::-;46211:7:::1;46222:1;46211:12:::0;46203:56:::1;;;::::0;-1:-1:-1;;;46203:56:0;;9621:2:1;46203:56:0::1;::::0;::::1;9603:21:1::0;9660:2;9640:18;;;9633:30;9699:33;9679:18;;;9672:61;9750:18;;46203:56:0::1;9419:355:1::0;46203:56:0::1;46285:8;:15:::0;46278:22;::::1;46270:54;;;::::0;-1:-1:-1;;;46270:54:0;;9981:2:1;46270:54:0::1;::::0;::::1;9963:21:1::0;10020:2;10000:18;;;9993:30;-1:-1:-1;;;10039:18:1;;;10032:49;10098:18;;46270:54:0::1;9779:343:1::0;46270:54:0::1;46337:17;46357:19;46368:7;46357:10;:19::i;:::-;46337:39;;46408:9;46395;:22;;46387:60;;;::::0;-1:-1:-1;;;46387:60:0;;10329:2:1;46387:60:0::1;::::0;::::1;10311:21:1::0;10368:2;10348:18;;;10341:30;10407:27;10387:18;;;10380:55;10452:18;;46387:60:0::1;10127:349:1::0;46387:60:0::1;46460:21;46484:8;46493:4;46484:14;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;46533;;;:8:::1;:14:::0;;;;;;46548:10:::1;46533:26:::0;;;;;;;46484:14:::1;::::0;;::::1;::::0;;::::1;::::0;-1:-1:-1;46572:16:0::1;46542:4:::0;46572:10:::1;:16::i;:::-;46629:11:::0;;46599:15:::1;::::0;46629;46625:408:::1;;46671:221;46876:4;:15;;;46671:182;46848:4;46671:154;46811:13;;46807:2;:17;;;;:::i;46671:221::-;46661:231:::0;-1:-1:-1;46911:11:0;;46907:115:::1;;46972:12;::::0;46943:11:::1;::::0;:63:::1;::::0;-1:-1:-1;;;;;46943:11:0;;::::1;::::0;46972:12:::1;46986:10;46998:7:::0;46943:28:::1;:63::i;:::-;47077:17:::0;;:70:::1;::::0;-1:-1:-1;;;;;47077:17:0::1;47112:10;47132:4;47139:7:::0;47077:34:::1;:70::i;:::-;47178:7;47158:4;:16;;;:27;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;47210:11:0;;:24:::1;::::0;47226:7;47210:15:::1;:24::i;:::-;47196:38:::0;;47387:13:::1;::::0;47263:162:::1;::::0;47420:4:::1;::::0;47263:138:::1;::::0;47383:17:::1;::::0;:2:::1;:17;:::i;47263:162::-;47245:15;::::0;::::1;:180:::0;47492:12:::1;::::0;47484:41:::1;::::0;-1:-1:-1;;;;;47492:12:0;;::::1;::::0;47484:41;::::1;;;::::0;47515:9;;47492:12:::1;47484:41:::0;47492:12;47484:41;47515:9;47492:12;47484:41;::::1;;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;47543:45:0::1;::::0;;373:25:1;;;429:2;414:18;;407:34;;;47565:4:0;;47553:10:::1;::::0;47543:45:::1;::::0;346:18:1;47543:45:0::1;;;;;;;46192:1404;;;;46083:1513:::0;;:::o;44243:235::-;2005:7;2032:6;-1:-1:-1;;;;;2032:6:0;736:10;2179:23;2171:68;;;;-1:-1:-1;;;2171:68:0;;;;;;;:::i;:::-;4645:4;4669:7;-1:-1:-1;;;4669:7:0;;;;4923:9:::1;4915:38;;;;-1:-1:-1::0;;;4915:38:0::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;44373:27:0;::::2;44365:66;;;::::0;-1:-1:-1;;;44365:66:0;;10813:2:1;44365:66:0::2;::::0;::::2;10795:21:1::0;10852:2;10832:18;;;10825:30;10891:28;10871:18;;;10864:56;10937:18;;44365:66:0::2;10611:350:1::0;44365:66:0::2;44442:12;:28:::0;;-1:-1:-1;;;;;;44442:28:0::2;-1:-1:-1::0;;;;;44442:28:0;;;::::2;::::0;;;::::2;::::0;;44243:235::o;2868:238::-;2005:7;2032:6;-1:-1:-1;;;;;2032:6:0;736:10;2179:23;2171:68;;;;-1:-1:-1;;;2171:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;2971:22:0;::::1;2949:110;;;::::0;-1:-1:-1;;;2949:110:0;;11168:2:1;2949:110:0::1;::::0;::::1;11150:21:1::0;11207:2;11187:18;;;11180:30;11246:34;11226:18;;;11219:62;-1:-1:-1;;;11297:18:1;;;11290:36;11343:19;;2949:110:0::1;10966:402:1::0;2949:110:0::1;3070:28;3089:8;3070:18;:28::i;28345:98::-:0;28403:7;28430:5;28434:1;28430;:5;:::i;27964:98::-;28022:7;28049:5;28053:1;28049;:5;:::i;28702:98::-;28760:7;28787:5;28791:1;28787;:5;:::i;29101:98::-;29159:7;29186:5;29190:1;29186;:5;:::i;21418:285::-;21616:68;;-1:-1:-1;;;;;11804:15:1;;;21616:68:0;;;11786:34:1;11856:15;;11836:18;;;11829:43;11888:18;;;11881:34;;;21562:133:0;;21596:5;;-1:-1:-1;;;21639:27:0;11721:18:1;;21616:68:0;;;;-1:-1:-1;;21616:68:0;;;;;;;;;;;;;;-1:-1:-1;;;;;21616:68:0;-1:-1:-1;;;;;;21616:68:0;;;;;;;;;;21562:19;:133::i;:::-;21418:285;;;;:::o;21162:248::-;21333:58;;-1:-1:-1;;;;;12118:32:1;;21333:58:0;;;12100:51:1;12167:18;;;12160:34;;;21279:123:0;;21313:5;;-1:-1:-1;;;21356:23:0;12073:18:1;;21333:58:0;11926:274:1;3266:191:0;3340:16;3359:6;;-1:-1:-1;;;;;3376:17:0;;;-1:-1:-1;;;;;;3376:17:0;;;;;;3409:40;;3359:6;;;;;;;3409:40;;3340:16;3409:40;3329:128;3266:191;:::o;24129:802::-;24553:23;24579:106;24621:4;24579:106;;;;;;;;;;;;;;;;;24587:5;-1:-1:-1;;;;;24579:27:0;;;:106;;;;;:::i;:::-;24700:17;;24553:132;;-1:-1:-1;24700:21:0;24696:228;;24815:10;24804:30;;;;;;;;;;;;:::i;:::-;24778:134;;;;-1:-1:-1;;;24778:134:0;;12689:2:1;24778:134:0;;;12671:21:1;12728:2;12708:18;;;12701:30;12767:34;12747:18;;;12740:62;-1:-1:-1;;;12818:18:1;;;12811:40;12868:19;;24778:134:0;12487:406:1;15570:229:0;15707:12;15739:52;15761:6;15769:4;15775:1;15778:12;15739:21;:52::i;:::-;15732:59;15570:229;-1:-1:-1;;;;15570:229:0:o;16786:571::-;16956:12;17028:5;17003:21;:30;;16981:118;;;;-1:-1:-1;;;16981:118:0;;13100:2:1;16981:118:0;;;13082:21:1;13139:2;13119:18;;;13112:30;13178:34;13158:18;;;13151:62;-1:-1:-1;;;13229:18:1;;;13222:36;13275:19;;16981:118:0;12898:402:1;16981:118:0;-1:-1:-1;;;;;13023:19:0;;;17110:60;;;;-1:-1:-1;;;17110:60:0;;13507:2:1;17110:60:0;;;13489:21:1;13546:2;13526:18;;;13519:30;13585:31;13565:18;;;13558:59;13634:18;;17110:60:0;13305:353:1;17110:60:0;17184:12;17198:23;17225:6;-1:-1:-1;;;;;17225:11:0;17244:5;17265:4;17225:55;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17183:97;;;;17298:51;17315:7;17324:10;17336:12;19896;19925:7;19921:530;;;-1:-1:-1;19956:10:0;19949:17;;19921:530;20070:17;;:21;20066:374;;20268:10;20262:17;20329:15;20316:10;20312:2;20308:19;20301:44;20066:374;20411:12;20404:20;;-1:-1:-1;;;20404:20:0;;;;;;;;:::i;14:180:1:-;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;165:23:1;;14:180;-1:-1:-1;14:180:1:o;1142:248::-;1210:6;1218;1271:2;1259:9;1250:7;1246:23;1242:32;1239:52;;;1287:1;1284;1277:12;1239:52;-1:-1:-1;;1310:23:1;;;1380:2;1365:18;;;1352:32;;-1:-1:-1;1142:248:1:o;1395:139::-;-1:-1:-1;;;;;1478:31:1;;1468:42;;1458:70;;1524:1;1521;1514:12;1539:337;1621:6;1629;1682:2;1670:9;1661:7;1657:23;1653:32;1650:52;;;1698:1;1695;1688:12;1650:52;1734:9;1721:23;1711:33;;1794:2;1783:9;1779:18;1766:32;1807:39;1840:5;1807:39;:::i;:::-;1865:5;1855:15;;;1539:337;;;;;:::o;2281:255::-;2340:6;2393:2;2381:9;2372:7;2368:23;2364:32;2361:52;;;2409:1;2406;2399:12;2361:52;2448:9;2435:23;2467:39;2500:5;2467:39;:::i;3091:356::-;3293:2;3275:21;;;3312:18;;;3305:30;3371:34;3366:2;3351:18;;3344:62;3438:2;3423:18;;3091:356::o;3452:340::-;3654:2;3636:21;;;3693:2;3673:18;;;3666:30;-1:-1:-1;;;3727:2:1;3712:18;;3705:46;3783:2;3768:18;;3452:340::o;3797:127::-;3858:10;3853:3;3849:20;3846:1;3839:31;3889:4;3886:1;3879:15;3913:4;3910:1;3903:15;4629:127;4690:10;4685:3;4681:20;4678:1;4671:31;4721:4;4718:1;4711:15;4745:4;4742:1;4735:15;4761:135;4800:3;4821:17;;;4818:43;;4841:18;;:::i;:::-;-1:-1:-1;4888:1:1;4877:13;;4761:135::o;4901:179::-;4979:13;;5032:22;5021:34;;5011:45;;5001:73;;5070:1;5067;5060:12;5001:73;4901:179;;;:::o;5085:473::-;5188:6;5196;5204;5212;5220;5273:3;5261:9;5252:7;5248:23;5244:33;5241:53;;;5290:1;5287;5280:12;5241:53;5313:39;5342:9;5313:39;:::i;:::-;5303:49;;5392:2;5381:9;5377:18;5371:25;5361:35;;5436:2;5425:9;5421:18;5415:25;5405:35;;5480:2;5469:9;5465:18;5459:25;5449:35;;5503:49;5547:3;5536:9;5532:19;5503:49;:::i;:::-;5493:59;;5085:473;;;;;;;;:::o;6270:422::-;6359:1;6402:5;6359:1;6416:270;6437:7;6427:8;6424:21;6416:270;;;6496:4;6492:1;6488:6;6484:17;6478:4;6475:27;6472:53;;;6505:18;;:::i;:::-;6555:7;6545:8;6541:22;6538:55;;;6575:16;;;;6538:55;6654:22;;;;6614:15;;;;6416:270;;;6420:3;6270:422;;;;;:::o;6697:806::-;6746:5;6776:8;6766:80;;-1:-1:-1;6817:1:1;6831:5;;6766:80;6865:4;6855:76;;-1:-1:-1;6902:1:1;6916:5;;6855:76;6947:4;6965:1;6960:59;;;;7033:1;7028:130;;;;6940:218;;6960:59;6990:1;6981:10;;7004:5;;;7028:130;7065:3;7055:8;7052:17;7049:43;;;7072:18;;:::i;:::-;-1:-1:-1;;7128:1:1;7114:16;;7143:5;;6940:218;;7242:2;7232:8;7229:16;7223:3;7217:4;7214:13;7210:36;7204:2;7194:8;7191:16;7186:2;7180:4;7177:12;7173:35;7170:77;7167:159;;;-1:-1:-1;7279:19:1;;;7311:5;;7167:159;7358:34;7383:8;7377:4;7358:34;:::i;:::-;7428:6;7424:1;7420:6;7416:19;7407:7;7404:32;7401:58;;;7439:18;;:::i;:::-;7477:20;;6697:806;-1:-1:-1;;;6697:806:1:o;7508:131::-;7568:5;7597:36;7624:8;7618:4;7597:36;:::i;7644:128::-;7711:9;;;7732:11;;;7729:37;;;7746:18;;:::i;8845:217::-;8885:1;8911;8901:132;;8955:10;8950:3;8946:20;8943:1;8936:31;8990:4;8987:1;8980:15;9018:4;9015:1;9008:15;8901:132;-1:-1:-1;9047:9:1;;8845:217::o;10481:125::-;10546:9;;;10567:10;;;10564:36;;;10580:18;;:::i;11373:168::-;11413:7;11479:1;11475;11471:6;11467:14;11464:1;11461:21;11456:1;11449:9;11442:17;11438:45;11435:71;;;11486:18;;:::i;:::-;-1:-1:-1;11526:9:1;;11373:168::o;12205:277::-;12272:6;12325:2;12313:9;12304:7;12300:23;12296:32;12293:52;;;12341:1;12338;12331:12;12293:52;12373:9;12367:16;12426:5;12419:13;12412:21;12405:5;12402:32;12392:60;;12448:1;12445;12438:12;13663:250;13748:1;13758:113;13772:6;13769:1;13766:13;13758:113;;;13848:11;;;13842:18;13829:11;;;13822:39;13794:2;13787:10;13758:113;;;-1:-1:-1;;13905:1:1;13887:16;;13880:27;13663:250::o;13918:287::-;14047:3;14085:6;14079:13;14101:66;14160:6;14155:3;14148:4;14140:6;14136:17;14101:66;:::i;:::-;14183:16;;;;;13918:287;-1:-1:-1;;13918:287:1:o;14210:396::-;14359:2;14348:9;14341:21;14322:4;14391:6;14385:13;14434:6;14429:2;14418:9;14414:18;14407:34;14450:79;14522:6;14517:2;14506:9;14502:18;14497:2;14489:6;14485:15;14450:79;:::i;:::-;14590:2;14569:15;-1:-1:-1;;14565:29:1;14550:45;;;;14597:2;14546:54;;14210:396;-1:-1:-1;;14210:396:1:o

ipfs://1efc0d8322a1844fd6662e6967742b487a45e774fa5373240a6437265ea0599e