Contract 0xb00D4C3A26d8AdC68b9dACe43F3280A2D702f0EC 11

/**
 *Submitted for verification at snowtrace.io on 2022-02-25
*/

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


// 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/IERC20.sol


// 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/token/ERC20/utils/SafeERC20.sol


// 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/security/ReentrancyGuard.sol


// 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/utils/Context.sol


// 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/security/Pausable.sol


// 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/access/Ownable.sol


// 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/utils/math/SafeMath.sol


// 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: contracts/Temple.sol



pragma solidity ^0.8.0;







contract Temple is Ownable, Pausable {
  using SafeMath for uint256;
  using SafeERC20 for IERC20;
  // Info of each user.
  struct UserInfo {
    uint256 amount; // How many LP tokens the user has provided.
    uint256 rewardDebt; // Reward debt. See explanation below.
  }
  // Info of each pool.
  struct PoolInfo {
    IERC20 lpToken; // Address of LP token contract.
    uint256 allocPoint; // How many allocation points assigned to this pool. Rewards to distribute per block.
    uint256 lastRewardTimestamp; // Last block number that Rewards distribution occurs.
    uint256 accRewardTokenPerShare; // Accumulated Rewards per share, times 1e30. See below.
  }
  // The stake token
  IERC20 public stakeToken;
  // The reward token
  IERC20 public rewardToken;
  // Reward tokens created per block.
  uint256 public rewardPerSecond;
  // Keep track of number of tokens staked in case the contract earns reflect fees
  uint256 public totalStaked = 0;
  // Info of each pool.
  PoolInfo public myPool;
  // Info of each user that stakes LP tokens.
  mapping(address => UserInfo) public userInfo;
  // Total allocation points. Must be the sum of all allocation points in all pools.
  uint256 private totalAllocPoint = 0;
  // The block number when Reward mining starts.
  uint256 public startTimestamp;
  // The block number when mining ends.
  uint256 public bonusEndTimestamp;
  event Deposit(address indexed user, uint256 amount);
  event DepositRewards(uint256 amount);
  event Withdraw(address indexed user, uint256 amount);
  event EmergencyWithdraw(address indexed user, uint256 amount);
  event EmergencyRewardWithdraw(address indexed user, uint256 amount);
  event SkimStakeTokenFees(address indexed user, uint256 amount);

  constructor(
    IERC20 _stakeToken,
    IERC20 _rewardToken,
    uint256 _rewardPerSecond,
    uint256 _startTimestamp,
    uint256 _bonusEndTimestamp
  ) {
    stakeToken = _stakeToken;
    rewardToken = _rewardToken;
    rewardPerSecond = _rewardPerSecond;
    startTimestamp = _startTimestamp;
    bonusEndTimestamp = _bonusEndTimestamp;
    // staking pool
    myPool = PoolInfo({ lpToken: _stakeToken, allocPoint: 1000, lastRewardTimestamp: startTimestamp, accRewardTokenPerShare: 0 });
    totalAllocPoint = 1000;
  }

  // Return reward multiplier over the given _from to _to block.
  function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) {
    if (_to <= bonusEndTimestamp) {
      return _to.sub(_from);
    } else if (_from >= bonusEndTimestamp) {
      return 0;
    } else {
      return bonusEndTimestamp.sub(_from);
    }
  }

  // View function to see pending Reward on frontend.
  function pendingReward(address _user) external view returns (uint256) {
    UserInfo storage user = userInfo[_user];
    uint256 accRewardTokenPerShare = myPool.accRewardTokenPerShare;
    if (block.timestamp > myPool.lastRewardTimestamp && totalStaked != 0) {
      uint256 multiplier = getMultiplier(myPool.lastRewardTimestamp, block.timestamp);
      uint256 tokenReward = multiplier.mul(rewardPerSecond).mul(myPool.allocPoint).div(totalAllocPoint);
      accRewardTokenPerShare = accRewardTokenPerShare.add(tokenReward.mul(1e30).div(totalStaked));
    }
    return user.amount.mul(accRewardTokenPerShare).div(1e30).sub(user.rewardDebt);
  }

  // Update reward variables of the given pool to be up-to-date.
  function updatePool() public whenNotPaused {
    if (block.timestamp <= myPool.lastRewardTimestamp) {
      return;
    }
    if (totalStaked == 0) {
      myPool.lastRewardTimestamp = block.timestamp;
      return;
    }
    uint256 multiplier = getMultiplier(myPool.lastRewardTimestamp, block.timestamp);
    uint256 tokenReward = multiplier.mul(rewardPerSecond).mul(myPool.allocPoint).div(totalAllocPoint);
    myPool.accRewardTokenPerShare = myPool.accRewardTokenPerShare.add(tokenReward.mul(1e30).div(totalStaked));
    myPool.lastRewardTimestamp = block.timestamp;
  }

  /// Deposit staking token into the contract to earn rewards.
  /// @dev Since this contract needs to be supplied with rewards we are
  ///  sending the balance of the contract if the pending rewards are higher
  /// @param _amount The amount of staking tokens to deposit
  function deposit(uint256 _amount) public whenNotPaused {
    UserInfo storage user = userInfo[msg.sender];
    uint256 finalDepositAmount = 0;
    updatePool();
    if (user.amount > 0) {
      uint256 pending = user.amount.mul(myPool.accRewardTokenPerShare).div(1e30).sub(user.rewardDebt);
      if (pending > 0) {
        uint256 currentRewardBalance = rewardBalance();
        if (currentRewardBalance > 0) {
          if (pending > currentRewardBalance) {
            safeTransferReward(address(msg.sender), currentRewardBalance);
          } else {
            safeTransferReward(address(msg.sender), pending);
          }
        }
      }
    }
    if (_amount > 0) {
      uint256 preStakeBalance = totalStakeTokenBalance();
      myPool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
      finalDepositAmount = totalStakeTokenBalance().sub(preStakeBalance);
      user.amount = user.amount.add(finalDepositAmount);
      totalStaked = totalStaked.add(finalDepositAmount);
    }
    user.rewardDebt = user.amount.mul(myPool.accRewardTokenPerShare).div(1e30);
    emit Deposit(msg.sender, finalDepositAmount);
  }

  /// Withdraw rewards and/or staked tokens. Pass a 0 amount to withdraw only rewards
  /// @param _amount The amount of staking tokens to withdraw
  function withdraw(uint256 _amount) public whenNotPaused {
    UserInfo storage user = userInfo[msg.sender];
    require(user.amount >= _amount, "withdraw: not good");
    updatePool();
    uint256 pending = user.amount.mul(myPool.accRewardTokenPerShare).div(1e30).sub(user.rewardDebt);
    if (pending > 0) {
      uint256 currentRewardBalance = rewardBalance();
      if (currentRewardBalance > 0) {
        if (pending > currentRewardBalance) {
          safeTransferReward(address(msg.sender), currentRewardBalance);
        } else {
          safeTransferReward(address(msg.sender), pending);
        }
      }
    }
    if (_amount > 0) {
      user.amount = user.amount.sub(_amount);
      myPool.lpToken.safeTransfer(address(msg.sender), _amount);
      totalStaked = totalStaked.sub(_amount);
    }
    user.rewardDebt = user.amount.mul(myPool.accRewardTokenPerShare).div(1e30);
    emit Withdraw(msg.sender, _amount);
  }

  /// Obtain the reward balance of this contract
  /// @return wei balace of conract
  function rewardBalance() public view returns (uint256) {
    return rewardToken.balanceOf(address(this));
  }

  // Deposit Rewards into contract
  function depositRewards(uint256 _amount) external {
    require(_amount > 0, "Deposit value must be greater than 0.");
    rewardToken.safeTransferFrom(address(msg.sender), address(this), _amount);
    emit DepositRewards(_amount);
  }

  /// @param _to address to send reward token to
  /// @param _amount value of reward token to transfer
  function safeTransferReward(address _to, uint256 _amount) internal {
    rewardToken.safeTransfer(_to, _amount);
  }

  /* Admin Functions */
  /// @param _rewardPerSecond The amount of reward tokens to be given per block
  function setRewardPerSecond(uint256 _rewardPerSecond) external onlyOwner {
    rewardPerSecond = _rewardPerSecond;
  }

  /// @param  _bonusEndTimestamp The block when rewards will end
  function setBonusEndTimestamp(uint256 _bonusEndTimestamp) external onlyOwner {
    // new bonus end block must be greater than current
    bonusEndTimestamp = _bonusEndTimestamp;
  }

  /// @dev Obtain the stake token fees (if any) earned by reflect token
  function getStakeTokenFeeBalance() public view returns (uint256) {
    return totalStakeTokenBalance().sub(totalStaked);
  }

  /// @dev Obtain the stake balance of this contract
  /// @return wei balace of contract
  function totalStakeTokenBalance() public view returns (uint256) {
    // Return BEO20 balance
    return stakeToken.balanceOf(address(this));
  }

  /// @dev Remove excess stake tokens earned by reflect fees
  function skimStakeTokenFees() external onlyOwner {
    uint256 stakeTokenFeeBalance = getStakeTokenFeeBalance();
    stakeToken.safeTransfer(msg.sender, stakeTokenFeeBalance);
    emit SkimStakeTokenFees(msg.sender, stakeTokenFeeBalance);
  }

  /* Emergency Functions */
  // Withdraw without caring about rewards. EMERGENCY ONLY.
  function emergencyWithdraw() external {
    UserInfo storage user = userInfo[msg.sender];
    myPool.lpToken.safeTransfer(address(msg.sender), user.amount);
    totalStaked = totalStaked.sub(user.amount);
    user.amount = 0;
    user.rewardDebt = 0;
    emit EmergencyWithdraw(msg.sender, user.amount);
  }

  // Withdraw reward. EMERGENCY ONLY.
  function emergencyRewardWithdraw(uint256 _amount) external onlyOwner {
    require(_amount <= rewardBalance(), "not enough rewards");
    // Withdraw rewards
    safeTransferReward(address(msg.sender), _amount);
    emit EmergencyRewardWithdraw(msg.sender, _amount);
  }

  function emergencyRewardWithdrawTotal() external onlyOwner {
    uint256 _amount = rewardBalance();
    // Withdraw rewards
    safeTransferReward(address(msg.sender), _amount);
    emit EmergencyRewardWithdraw(msg.sender, _amount);
  }

  /**
   * enables owner to pause / unpause minting
   */
  function setPaused(bool _paused) external onlyOwner {
    if (_paused) _pause();
    else _unpause();
  }
}

[{"inputs":[{"internalType":"contract IERC20","name":"_stakeToken","type":"address"},{"internalType":"contract IERC20","name":"_rewardToken","type":"address"},{"internalType":"uint256","name":"_rewardPerSecond","type":"uint256"},{"internalType":"uint256","name":"_startTimestamp","type":"uint256"},{"internalType":"uint256","name":"_bonusEndTimestamp","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"DepositRewards","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyRewardWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","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":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"SkimStakeTokenFees","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":"Withdraw","type":"event"},{"inputs":[],"name":"bonusEndTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"depositRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"emergencyRewardWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"emergencyRewardWithdrawTotal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","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":[],"name":"getStakeTokenFeeBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"myPool","outputs":[{"internalType":"contract IERC20","name":"lpToken","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardTimestamp","type":"uint256"},{"internalType":"uint256","name":"accRewardTokenPerShare","type":"uint256"}],"stateMutability":"view","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":"address","name":"_user","type":"address"}],"name":"pendingReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPerSecond","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":"_bonusEndTimestamp","type":"uint256"}],"name":"setBonusEndTimestamp","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_paused","type":"bool"}],"name":"setPaused","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_rewardPerSecond","type":"uint256"}],"name":"setRewardPerSecond","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"skimStakeTokenFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stakeToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"startTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalStakeTokenBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalStaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"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":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000e0c109583d69dca33dc59dc7ce45c10e3b8dfc57000000000000000000000000b31f66aa3c1e785363f0875a1b74e27b85fd66c700000000000000000000000000000000000000000000000000009184e72a000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001508356912000

-----Decoded View---------------
Arg [0] : _stakeToken (address): 0xe0c109583d69dca33dc59dc7ce45c10e3b8dfc57
Arg [1] : _rewardToken (address): 0xb31f66aa3c1e785363f0875a1b74e27b85fd66c7
Arg [2] : _rewardPerSecond (uint256): 160000000000000
Arg [3] : _startTimestamp (uint256): 0
Arg [4] : _bonusEndTimestamp (uint256): 370000000000000

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 000000000000000000000000e0c109583d69dca33dc59dc7ce45c10e3b8dfc57
Arg [1] : 000000000000000000000000b31f66aa3c1e785363f0875a1b74e27b85fd66c7
Arg [2] : 00000000000000000000000000000000000000000000000000009184e72a0000
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [4] : 0000000000000000000000000000000000000000000000000001508356912000

30978:9728:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40595:108;;;;;;:::i;:::-;;:::i;:::-;;32058:44;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;7976:25:1;;;8032:2;8017:18;;8010:34;;;;7949:18;32058:44:0;;;;;;;;36630:952;;;;;;:::i;:::-;;:::i;40006:275::-;;;;;;:::i;:::-;;:::i;31984:22::-;;;;;;;;;;;-1:-1:-1;;;;;31984:22:0;;;;;;;;;;-1:-1:-1;;;;;3321:32:1;;;3303:51;;3385:2;3370:18;;3363:34;;;;3413:18;;;3406:34;3471:2;3456:18;;3449:34;3290:3;3275:19;31984:22:0;3257:232:1;31684:24:0;;;;;-1:-1:-1;;;;;31684:24:0;;;;;;-1:-1:-1;;;;;1941:32:1;;;1923:51;;1911:2;1896:18;31684:24:0;1878:102:1;20159:86:0;20206:4;20230:7;-1:-1:-1;;;20230:7:0;;;;20159:86;;2809:14:1;;2802:22;2784:41;;2772:2;2757:18;20159:86:0;2739:92:1;38409:120:0;;;;;;:::i;:::-;;:::i;23058:103::-;;;:::i;38865:126::-;;;:::i;:::-;;;7766:25:1;;;7754:2;7739:18;38865:126:0;7721:76:1;31924:30:0;;;;;;37828:239;;;;;;:::i;:::-;;:::i;22407:87::-;22453:7;22480:6;-1:-1:-1;;;;;22480:6:0;22407:87;;33367:282;;;;;;:::i;:::-;;:::i;31805:30::-;;;;;;39305:246;;;:::i;39089:148::-;;;:::i;37675:111::-;;;:::i;35304:1170::-;;;;;;:::i;:::-;;:::i;38601:185::-;;;;;;:::i;:::-;;:::i;39647:314::-;;;:::i;34435:586::-;;;:::i;32358:32::-;;;;;;32283:29;;;;;;40287:241;;;:::i;23316:201::-;;;;;;:::i;:::-;;:::i;33710:653::-;;;;;;:::i;:::-;;:::i;31736:25::-;;;;;-1:-1:-1;;;;;31736:25:0;;;40595:108;22453:7;22480:6;-1:-1:-1;;;;;22480:6:0;18893:10;22627:23;22619:68;;;;-1:-1:-1;;;22619:68:0;;;;;;;:::i;:::-;;;;;;;;;40658:7:::1;40654:43;;;40667:8;:6;:8::i;:::-;40595:108:::0;:::o;40654:43::-:1;40687:10;:8;:10::i;36630:952::-:0;20206:4;20230:7;-1:-1:-1;;;20230:7:0;;;;20484:9;20476:38;;;;-1:-1:-1;;;20476:38:0;;;;;;;:::i;:::-;36726:10:::1;36693:21;36717:20:::0;;;:8:::1;:20;::::0;;;;36752:11;;:22;-1:-1:-1;36752:22:0::1;36744:53;;;::::0;-1:-1:-1;;;36744:53:0;;7064:2:1;36744:53:0::1;::::0;::::1;7046:21:1::0;7103:2;7083:18;;;7076:30;-1:-1:-1;;;7122:18:1;;;7115:48;7180:18;;36744:53:0::1;7036:168:1::0;36744:53:0::1;36804:12;:10;:12::i;:::-;36823:15;36841:77;36902:4;:15;;;36841:56;-1:-1:-1::0;;;36841:46:0::1;36857:6;:29;;;36841:4;:11;;;:15;;:46;;;;:::i;:::-;:50:::0;::::1;:56::i;:::-;:60:::0;::::1;:77::i;:::-;36823:95:::0;-1:-1:-1;36929:11:0;;36925:339:::1;;36951:28;36982:15;:13;:15::i;:::-;36951:46:::0;-1:-1:-1;37010:24:0;;37006:251:::1;;37061:20;37051:7;:30;37047:201;;;37096:61;37123:10;37136:20;37096:18;:61::i;:::-;37047:201;;;37188:48;37215:10;37228:7;37188:18;:48::i;:::-;36925:339;;37274:11:::0;;37270:185:::1;;37310:11:::0;;:24:::1;::::0;37326:7;37310:15:::1;:24::i;:::-;37296:38:::0;;37343:6:::1;:14:::0;:57:::1;::::0;-1:-1:-1;;;;;37343:14:0::1;37379:10;37392:7:::0;37343:27:::1;:57::i;:::-;37423:11;::::0;:24:::1;::::0;37439:7;37423:15:::1;:24::i;:::-;37409:11;:38:::0;37270:185:::1;37495:29:::0;;37479:11;;:56:::1;::::0;-1:-1:-1;;;37530:4:0;37479:46:::1;::::0;:15:::1;:46::i;:56::-;37461:15;::::0;::::1;:74:::0;37547:29:::1;::::0;7766:25:1;;;37556:10:0::1;::::0;37547:29:::1;::::0;7754:2:1;7739:18;37547:29:0::1;;;;;;;;20525:1;;36630:952:::0;:::o;40006:275::-;22453:7;22480:6;-1:-1:-1;;;;;22480:6:0;18893:10;22627:23;22619:68;;;;-1:-1:-1;;;22619:68:0;;;;;;;:::i;:::-;40101:15:::1;:13;:15::i;:::-;40090:7;:26;;40082:57;;;::::0;-1:-1:-1;;;40082:57:0;;4433:2:1;40082:57:0::1;::::0;::::1;4415:21:1::0;4472:2;4452:18;;;4445:30;-1:-1:-1;;;4491:18:1;;;4484:48;4549:18;;40082:57:0::1;4405:168:1::0;40082:57:0::1;40171:48;40198:10;40211:7;40171:18;:48::i;:::-;40231:44;::::0;7766:25:1;;;40255:10:0::1;::::0;40231:44:::1;::::0;7754:2:1;7739:18;40231:44:0::1;;;;;;;;40006:275:::0;:::o;38409:120::-;22453:7;22480:6;-1:-1:-1;;;;;22480:6:0;18893:10;22627:23;22619:68;;;;-1:-1:-1;;;22619:68:0;;;;;;;:::i;:::-;38489:15:::1;:34:::0;38409:120::o;23058:103::-;22453:7;22480:6;-1:-1:-1;;;;;22480:6:0;18893:10;22627:23;22619:68;;;;-1:-1:-1;;;22619:68:0;;;;;;;:::i;:::-;23123:30:::1;23150:1;23123:18;:30::i;:::-;23058:103::o:0;38865:126::-;38921:7;38944:41;38973:11;;38944:24;:22;:24::i;:41::-;38937:48;;38865:126;:::o;37828:239::-;37903:1;37893:7;:11;37885:61;;;;-1:-1:-1;;;37885:61:0;;6300:2:1;37885:61:0;;;6282:21:1;6339:2;6319:18;;;6312:30;6378:34;6358:18;;;6351:62;-1:-1:-1;;;6429:18:1;;;6422:35;6474:19;;37885:61:0;6272:227:1;37885:61:0;37953:11;;:73;;-1:-1:-1;;;;;37953:11:0;37990:10;38011:4;38018:7;37953:28;:73::i;:::-;38038:23;;7766:25:1;;;38038:23:0;;7754:2:1;7739:18;38038:23:0;;;;;;;37828:239;:::o;33367:282::-;33439:7;33466:17;;33459:3;:24;33455:189;;33501:14;:3;33509:5;33501:7;:14::i;:::-;33494:21;;;;33455:189;33542:17;;33533:5;:26;33529:115;;-1:-1:-1;33577:1:0;33570:8;;33529:115;33608:17;;:28;;33630:5;33608:21;:28::i;33529:115::-;33367:282;;;;:::o;39305:246::-;22453:7;22480:6;-1:-1:-1;;;;;22480:6:0;18893:10;22627:23;22619:68;;;;-1:-1:-1;;;22619:68:0;;;;;;;:::i;:::-;39361:28:::1;39392:25;:23;:25::i;:::-;39424:10;::::0;39361:56;;-1:-1:-1;39424:57:0::1;::::0;-1:-1:-1;;;;;39424:10:0::1;39448;39361:56:::0;39424:23:::1;:57::i;:::-;39493:52;::::0;7766:25:1;;;39512:10:0::1;::::0;39493:52:::1;::::0;7754:2:1;7739:18;39493:52:0::1;7721:76:1::0;39089:148:0;39196:10;;:35;;-1:-1:-1;;;39196:35:0;;39225:4;39196:35;;;1923:51:1;39144:7:0;;-1:-1:-1;;;;;39196:10:0;;:20;;1896:18:1;;39196:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;37675:111::-;37744:11;;:36;;-1:-1:-1;;;37744:36:0;;37774:4;37744:36;;;1923:51:1;37721:7:0;;-1:-1:-1;;;;;37744:11:0;;:21;;1896:18:1;;37744:36:0;1878:102:1;35304:1170:0;20206:4;20230:7;-1:-1:-1;;;20230:7:0;;;;20484:9;20476:38;;;;-1:-1:-1;;;20476:38:0;;;;;;;:::i;:::-;35399:10:::1;35366:21;35390:20:::0;;;:8:::1;:20;::::0;;;;;35454:12:::1;:10;:12::i;:::-;35477:11:::0;;:15;35473:498:::1;;35503:15;35521:77;35582:4;:15;;;35521:56;-1:-1:-1::0;;;35521:46:0::1;35537:6;:29;;;35521:4;:11;;;:15;;:46;;;;:::i;:77::-;35503:95:::0;-1:-1:-1;35611:11:0;;35607:357:::1;;35635:28;35666:15;:13;:15::i;:::-;35635:46:::0;-1:-1:-1;35696:24:0;;35692:263:::1;;35749:20;35739:7;:30;35735:209;;;35786:61;35813:10;35826:20;35786:18;:61::i;:::-;35735:209;;;35882:48;35909:10;35922:7;35882:18;:48::i;:::-;35607:357;;35473:498;;35981:11:::0;;35977:360:::1;;36003:23;36029:24;:22;:24::i;:::-;36062:6;:14:::0;36003:50;;-1:-1:-1;36062:76:0::1;::::0;-1:-1:-1;;;;;36062:14:0::1;36102:10;36123:4;36130:7:::0;36062:31:::1;:76::i;:::-;36168:45;36197:15;36168:24;:22;:24::i;:45::-;36236:11:::0;;36147:66;;-1:-1:-1;36236:35:0::1;::::0;36147:66;36236:15:::1;:35::i;:::-;36222:49:::0;;36294:11:::1;::::0;:35:::1;::::0;36310:18;36294:15:::1;:35::i;:::-;36280:11;:49:::0;-1:-1:-1;35977:360:0::1;36377:29:::0;;36361:11;;:56:::1;::::0;-1:-1:-1;;;36412:4:0;36361:46:::1;::::0;:15:::1;:46::i;:56::-;36343:15;::::0;::::1;:74:::0;36429:39:::1;::::0;7766:25:1;;;36437:10:0::1;::::0;36429:39:::1;::::0;7754:2:1;7739:18;36429:39:0::1;7721:76:1::0;38601:185:0;22453:7;22480:6;-1:-1:-1;;;;;22480:6:0;18893:10;22627:23;22619:68;;;;-1:-1:-1;;;22619:68:0;;;;;;;:::i;:::-;38742:17:::1;:38:::0;38601:185::o;39647:314::-;39725:10;39692:21;39716:20;;;:8;:20;;;;;39792:11;;39743:6;:14;39716:20;;39743:61;;-1:-1:-1;;;;;39743:14:0;;:27;:61::i;:::-;39841:11;;39825;;:28;;:15;:28::i;:::-;39811:11;:42;39874:1;39860:15;;;39882;;;:19;;;39913:42;;7766:25:1;;;39931:10:0;;39913:42;;7754:2:1;7739:18;39913:42:0;7721:76:1;34435:586:0;20206:4;20230:7;-1:-1:-1;;;20230:7:0;;;;20484:9;20476:38;;;;-1:-1:-1;;;20476:38:0;;;;;;;:::i;:::-;34508:26;;34489:15:::1;:45;34485:74;;23058:103::o:0;34485:74::-:1;34569:11;::::0;34565:98:::1;;34625:15;34596:26:::0;:44;23058:103::o;34565:98::-:1;34669:18;34690:58;34704:6;:26;;;34732:15;34690:13;:58::i;:::-;34669:79;;34755:19;34777:75;34836:15;;34777:54;34813:6;:17;;;34777:31;34792:15;;34777:10;:14;;:31;;;;:::i;:::-;:35:::0;::::1;:54::i;:75::-;34755:97;;34891:73;34925:38;34951:11;;34925:21;-1:-1:-1::0;;;34925:11:0::1;:15;;:21;;;;:::i;:38::-;34891:29:::0;;;:33:::1;:73::i;:::-;34859:29:::0;:105;-1:-1:-1;;35000:15:0::1;34971:26:::0;:44;34435:586::o;40287:241::-;22453:7;22480:6;-1:-1:-1;;;;;22480:6:0;18893:10;22627:23;22619:68;;;;-1:-1:-1;;;22619:68:0;;;;;;;:::i;:::-;40353:15:::1;40371;:13;:15::i;:::-;40353:33;;40418:48;40445:10;40458:7;40418:18;:48::i;23316:201::-:0;22453:7;22480:6;-1:-1:-1;;;;;22480:6:0;18893:10;22627:23;22619:68;;;;-1:-1:-1;;;22619:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;23405:22:0;::::1;23397:73;;;::::0;-1:-1:-1;;;23397:73:0;;4780:2:1;23397:73:0::1;::::0;::::1;4762:21:1::0;4819:2;4799:18;;;4792:30;4858:34;4838:18;;;4831:62;-1:-1:-1;;;4909:18:1;;;4902:36;4955:19;;23397:73:0::1;4752:228:1::0;23397:73:0::1;23481:28;23500:8;23481:18;:28::i;33710:653::-:0;-1:-1:-1;;;;;33811:15:0;;33771:7;33811:15;;;:8;:15;;;;;33866:29;;33924:26;;33906:15;:44;:64;;;;-1:-1:-1;33954:11:0;;:16;;33906:64;33902:372;;;33981:18;34002:58;34016:6;:26;;;34044:15;34002:13;:58::i;:::-;33981:79;;34069:19;34091:75;34150:15;;34091:54;34127:6;:17;;;34091:31;34106:15;;34091:10;:14;;:31;;;;:::i;:75::-;34069:97;;34200:66;34227:38;34253:11;;34227:21;-1:-1:-1;;;34227:11:0;:15;;:21;;;;:::i;:38::-;34200:22;;:26;:66::i;:::-;34175:91;;33902:372;;;34287:70;34341:4;:15;;;34287:49;-1:-1:-1;;;34287:39:0;34303:22;34287:4;:11;;;:15;;:39;;;;:::i;:70::-;34280:77;33710:653;-1:-1:-1;;;;33710:653:0:o;20959:118::-;20206:4;20230:7;-1:-1:-1;;;20230:7:0;;;;20484:9;20476:38;;;;-1:-1:-1;;;20476:38:0;;;;;;;:::i;:::-;21019:7:::1;:14:::0;;-1:-1:-1;;;;21019:14:0::1;-1:-1:-1::0;;;21019:14:0::1;::::0;;21049:20:::1;21056:12;18893:10:::0;;18813:98;21056:12:::1;21049:20;::::0;-1:-1:-1;;;;;1941:32:1;;;1923:51;;1911:2;1896:18;21049:20:0::1;;;;;;;20959:118::o:0;21218:120::-;20206:4;20230:7;-1:-1:-1;;;20230:7:0;;;;20754:41;;;;-1:-1:-1;;;20754:41:0;;4084:2:1;20754:41:0;;;4066:21:1;4123:2;4103:18;;;4096:30;-1:-1:-1;;;4142:18:1;;;4135:50;4202:18;;20754:41:0;4056:170:1;20754:41:0;21287:5:::1;21277:15:::0;;-1:-1:-1;;;;21277:15:0::1;::::0;;21308:22:::1;18893:10:::0;21317:12:::1;18813:98:::0;27475;27533:7;27560:5;27564:1;27560;:5;:::i;:::-;27553:12;27475:98;-1:-1:-1;;;27475:98:0:o;27874:::-;27932:7;27959:5;27963:1;27959;:5;:::i;27118:98::-;27176:7;27203:5;27207:1;27203;:5;:::i;38179:118::-;38253:11;;:38;;-1:-1:-1;;;;;38253:11:0;38278:3;38283:7;38253:24;:38::i;:::-;38179:118;;:::o;12079:211::-;12223:58;;-1:-1:-1;;;;;2557:32:1;;12223:58:0;;;2539:51:1;2606:18;;;2599:34;;;12196:86:0;;12216:5;;-1:-1:-1;;;12246:23:0;2512:18:1;;12223:58:0;;;;-1:-1:-1;;12223:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;12223:58:0;-1:-1:-1;;;;;;12223:58:0;;;;;;;;;;12196:19;:86::i;:::-;12079:211;;;:::o;23677:191::-;23751:16;23770:6;;-1:-1:-1;;;;;23787:17:0;;;-1:-1:-1;;;;;;23787:17:0;;;;;;23820:40;;23770:6;;;;;;;23820:40;;23751:16;23820:40;23677:191;;:::o;12298:248::-;12469:68;;-1:-1:-1;;;;;2243:15:1;;;12469:68:0;;;2225:34:1;2295:15;;2275:18;;;2268:43;2327:18;;;2320:34;;;12442:96:0;;12462:5;;-1:-1:-1;;;12492:27:0;2160:18:1;;12469:68:0;2142:218:1;12442:96:0;12298:248;;;;:::o;26737:98::-;26795:7;26822:5;26826:1;26822;:5;:::i;14652:716::-;15076:23;15102:69;15130:4;15102:69;;;;;;;;;;;;;;;;;15110:5;-1:-1:-1;;;;;15102:27:0;;;:69;;;;;:::i;:::-;15186:17;;15076:95;;-1:-1:-1;15186:21:0;15182:179;;15283:10;15272:30;;;;;;;;;;;;:::i;:::-;15264:85;;;;-1:-1:-1;;;15264:85:0;;7411:2:1;15264:85:0;;;7393:21:1;7450:2;7430:18;;;7423:30;7489:34;7469:18;;;7462:62;-1:-1:-1;;;7540:18:1;;;7533:40;7590:19;;15264:85:0;7383:232:1;3978:229:0;4115:12;4147:52;4169:6;4177:4;4183:1;4186:12;4115;-1:-1:-1;;;;;1528:19:0;;;5385:60;;;;-1:-1:-1;;;5385:60:0;;6706:2:1;5385:60:0;;;6688:21:1;6745:2;6725:18;;;6718:30;6784:31;6764:18;;;6757:59;6833:18;;5385:60:0;6678:179:1;5385:60:0;5459:12;5473:23;5500:6;-1:-1:-1;;;;;5500:11:0;5519:5;5526:4;5500:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5458:73;;;;5549:51;5566:7;5575:10;5587:12;5549:16;:51::i;:::-;5542:58;5098:510;-1:-1:-1;;;;;;;5098:510:0:o;7784:712::-;7934:12;7963:7;7959:530;;;-1:-1:-1;7994:10:0;7987:17;;7959:530;8108:17;;:21;8104:374;;8306:10;8300:17;8367:15;8354:10;8350:2;8346:19;8339:44;8254:148;8449:12;8442:20;;-1:-1:-1;;;8442:20:0;;;;;;;;:::i;14:306:1:-;73:6;126:2;114:9;105:7;101:23;97:32;94:2;;;147:6;139;132:22;94:2;178:23;;-1:-1:-1;;;;;230:31:1;;220:42;;210:2;;281:6;273;266:22;325:251;381:6;434:2;422:9;413:7;409:23;405:32;402:2;;;455:6;447;440:22;402:2;499:9;486:23;518:28;540:5;518:28;:::i;581:255::-;648:6;701:2;689:9;680:7;676:23;672:32;669:2;;;722:6;714;707:22;669:2;759:9;753:16;778:28;800:5;778:28;:::i;841:190::-;900:6;953:2;941:9;932:7;928:23;924:32;921:2;;;974:6;966;959:22;921:2;-1:-1:-1;1002:23:1;;911:120;-1:-1:-1;911:120:1:o;1036:194::-;1106:6;1159:2;1147:9;1138:7;1134:23;1130:32;1127:2;;;1180:6;1172;1165:22;1127:2;-1:-1:-1;1208:16:1;;1117:113;-1:-1:-1;1117:113:1:o;1235:258::-;1303:6;1311;1364:2;1352:9;1343:7;1339:23;1335:32;1332:2;;;1385:6;1377;1370:22;1332:2;-1:-1:-1;;1413:23:1;;;1483:2;1468:18;;;1455:32;;-1:-1:-1;1322:171:1:o;1498:274::-;1627:3;1665:6;1659:13;1681:53;1727:6;1722:3;1715:4;1707:6;1703:17;1681:53;:::i;:::-;1750:16;;;;;1635:137;-1:-1:-1;;1635:137:1:o;3494:383::-;3643:2;3632:9;3625:21;3606:4;3675:6;3669:13;3718:6;3713:2;3702:9;3698:18;3691:34;3734:66;3793:6;3788:2;3777:9;3773:18;3768:2;3760:6;3756:15;3734:66;:::i;:::-;3861:2;3840:15;-1:-1:-1;;3836:29:1;3821:45;;;;3868:2;3817:54;;3615:262;-1:-1:-1;;3615:262:1:o;5392:340::-;5594:2;5576:21;;;5633:2;5613:18;;;5606:30;-1:-1:-1;;;5667:2:1;5652:18;;5645:46;5723:2;5708:18;;5566:166::o;5737:356::-;5939:2;5921:21;;;5958:18;;;5951:30;6017:34;6012:2;5997:18;;5990:62;6084:2;6069:18;;5911:182::o;8055:128::-;8095:3;8126:1;8122:6;8119:1;8116:13;8113:2;;;8132:18;;:::i;:::-;-1:-1:-1;8168:9:1;;8103:80::o;8188:217::-;8228:1;8254;8244:2;;-1:-1:-1;;;8279:31:1;;8333:4;8330:1;8323:15;8361:4;8286:1;8351:15;8244:2;-1:-1:-1;8390:9:1;;8234:171::o;8410:168::-;8450:7;8516:1;8512;8508:6;8504:14;8501:1;8498:21;8493:1;8486:9;8479:17;8475:45;8472:2;;;8523:18;;:::i;:::-;-1:-1:-1;8563:9:1;;8462:116::o;8583:125::-;8623:4;8651:1;8648;8645:8;8642:2;;;8656:18;;:::i;:::-;-1:-1:-1;8693:9:1;;8632:76::o;8713:258::-;8785:1;8795:113;8809:6;8806:1;8803:13;8795:113;;;8885:11;;;8879:18;8866:11;;;8859:39;8831:2;8824:10;8795:113;;;8926:6;8923:1;8920:13;8917:2;;;-1:-1:-1;;8961:1:1;8943:16;;8936:27;8766:205::o;8976:127::-;9037:10;9032:3;9028:20;9025:1;9018:31;9068:4;9065:1;9058:15;9092:4;9089:1;9082:15;9108:118;9194:5;9187:13;9180:21;9173:5;9170:32;9160:2;;9216:1;9213;9206:12

ipfs://7b385bf9e5c78d2013532e5c27d2474e221571782da96fbde8f82fe1691fec49