Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at Arbiscan.io on 2023-05-21
*/

/*
────────────────────────────────────────────────────────────────────────────
─██████████████─██████──██████─██████████████─██████████████─██████████████─
─██░░░░░░░░░░██─██░░██──██░░██─██░░░░░░░░░░██─██░░░░░░░░░░██─██░░░░░░░░░░██─
─██░░██████████─██░░██──██░░██─██░░██████░░██─██░░██████████─██████░░██████─
─██░░██─────────██░░██──██░░██─██░░██──██░░██─██░░██─────────────██░░██─────
─██░░██─────────██░░██████░░██─██░░██████░░██─██░░██████████─────██░░██─────
─██░░██──██████─██░░░░░░░░░░██─██░░░░░░░░░░██─██░░░░░░░░░░██─────██░░██─────
─██░░██──██░░██─██░░██████░░██─██░░██████░░██─██████████░░██─────██░░██─────
─██░░██──██░░██─██░░██──██░░██─██░░██──██░░██─────────██░░██─────██░░██─────
─██░░██████░░██─██░░██──██░░██─██░░██──██░░██─██████████░░██─────██░░██─────
─██░░░░░░░░░░██─██░░██──██░░██─██░░██──██░░██─██░░░░░░░░░░██─────██░░██─────
─██████████████─██████──██████─██████──██████─██████████████─────██████─────
────────────────────────────────────────────────────────────────────────────
https://ghastprotocol.com/
*/

// File: @openzeppelin/contracts/security/ReentrancyGuard.sol


// OpenZeppelin Contracts (last updated v4.8.0) (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() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

    function _nonReentrantAfter() private {
        // 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/access/Ownable.sol


// OpenZeppelin Contracts (last updated v4.7.0) (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 Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        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 (last updated v4.6.0) (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 subtraction 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: @openzeppelin/contracts/utils/Address.sol


// OpenZeppelin Contracts (last updated v4.8.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 functionCallWithValue(target, data, 0, "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");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or 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 {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// File: @openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

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


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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);

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

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


// OpenZeppelin Contracts (last updated v4.8.0) (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));
        }
    }

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

    /**
     * @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: src/gha.sol


pragma solidity ^0.8.0;








contract GHAstaking is Ownable,ReentrancyGuard {

    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    // Info of each user.
    struct UserInfo {
   
        uint256 RPamount;
        uint256 amount;     // How many LP tokens the user has provided.
        uint256 rewardDebt; // Reward debt. See explanation below.
        uint256 RPrewardDebt; // Reward debt. See explanation below.
        //
        // We do some fancy math here. Basically, any point in time, the amount of WETHs
        // entitled to a user but is pending to be distributed is:
        //
        //   pending reward = (user.amount * pool.accWETHPerShare) - user.rewardDebt
        //
        // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
        //   1. The pool's `accWETHPerShare` (and `lastRewardBlock`) gets updated.
        //   2. User receives the pending reward sent to his/her address.
        //   3. User's `amount` gets updated.
        //   4. User's `rewardDebt` gets updated.
    }

    // Info of each pool.
    struct PoolInfo {
        IERC20 lpToken;           // Address of LP token contract.
        uint256 totalRP;
        uint256 allocPoint;       // How many allocation points assigned to this pool. WETHs to distribute per block.
        uint256 lastRewardTime;  // Last block time that WETHs distribution occurs.
        uint256 accWETHPerShare; // Accumulated WETHs per share, times 1e12. See below.
        uint256 accRPPerShare; //RPpershare
    }

    IERC20 public WETH = IERC20(0x82aF49447D8a07e3bd95BD0d56f35241523fBab1);

    // Dev addresses
    address teamD;
    address teamD2;
    address teamD3;
    address teamD4;
    // WETH tokens created per block.
    uint256 public WETHPerSecond;
    uint256 public RPPerSecond;

    uint256 public totalWETHdistributed = 0;


    // set a max WETH per second, which can never be higher than 1 per second
    uint256 public constant maxWETHPerSecond = 1e18;

    uint256 public constant MaxAllocPoint = 4000;

    // Info of each pool.
    PoolInfo[] public poolInfo;
    // Info of each user that stakes LP tokens.
    mapping (uint256 => mapping (address => UserInfo)) public userInfo;
    // Total allocation points. Must be the sum of all allocation points in all pools.
    uint256 public totalAllocPoint = 0;
    // The block time when WETH mining starts.
    uint256 public immutable startTime;

    bool public withdrawable = false;

    event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
    event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);

    constructor(
        uint256 _WETHPerSecond,
        uint256 _RPPerSecond,
        uint256 _startTime
    ) {

        WETHPerSecond = _WETHPerSecond;
        startTime = _startTime;
        RPPerSecond = _RPPerSecond;
    }

    function openWithdraw() external onlyOwner{
        withdrawable = true;
    }
        
    function closeWithdraw() external onlyOwner{
        withdrawable = false;
    }

    function supplyRewards(uint256 _amount) external onlyOwner {
        totalWETHdistributed = totalWETHdistributed.add(_amount);
        WETH.transferFrom(msg.sender, address(this), _amount);
        uint256 teamAmount = _amount.mul(500).div(10000); 
        WETH.transfer(teamD, teamAmount);
        WETH.transfer(teamD2, teamAmount);
        WETH.transfer(teamD3, teamAmount);
        WETH.transfer(teamD4, teamAmount);
    }

    function poolLength() external view returns (uint256) {
        return poolInfo.length;
    }

    // Changes WETH token reward per second, with a cap of maxWETH per second
    // Good practice to update pools without messing up the contract
    function setWETHPerSecond(uint256 _WETHPerSecond) external onlyOwner {
        require(_WETHPerSecond <= maxWETHPerSecond, "setWETHPerSecond: too many WETHs!");

        // This MUST be done or pool rewards will be calculated with new WETH per second
        // This could unfairly punish small pools that dont have frequent deposits/withdraws/harvests
        massUpdatePools(); 

        WETHPerSecond = _WETHPerSecond;
    }

    function setRPPerSecond(uint256 _RPPerSecond) external onlyOwner {

        // This MUST be done or pool rewards will be calculated with new WETH per second
        // This could unfairly punish small pools that dont have frequent deposits/withdraws/harvests
        massUpdatePools(); 

        RPPerSecond = _RPPerSecond;
    }

    function checkForDuplicate(IERC20 _lpToken) internal view {
        uint256 length = poolInfo.length;
        for (uint256 _pid = 0; _pid < length; _pid++) {
            require(poolInfo[_pid].lpToken != _lpToken, "add: pool already exists!!!!");
        }
    }

    // Add a new lp to the pool. Can only be called by the owner.
    function add(uint256 _allocPoint, IERC20 _lpToken) external onlyOwner {
        require(_allocPoint <= MaxAllocPoint, "add: too many alloc points!!");

        checkForDuplicate(_lpToken); // ensure you cant add duplicate pools

        massUpdatePools();

        uint256 lastRewardTime = block.timestamp > startTime ? block.timestamp : startTime;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        poolInfo.push(PoolInfo({
            lpToken: _lpToken,
            totalRP: 0,
            allocPoint: _allocPoint,
            lastRewardTime: lastRewardTime,
            accWETHPerShare: 0,
            accRPPerShare:0
        }));
    }

    // Update the given pool's WETH allocation point. Can only be called by the owner.
    function set(uint256 _pid, uint256 _allocPoint) external onlyOwner {
        require(_allocPoint <= MaxAllocPoint, "add: too many alloc points!!");

        massUpdatePools();

        totalAllocPoint = totalAllocPoint - poolInfo[_pid].allocPoint + _allocPoint;
        poolInfo[_pid].allocPoint = _allocPoint;
    }

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

    // View function to see pending WETHs on frontend.
    function pendingWETH(uint256 _pid, address _user) external view returns (uint256) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accWETHPerShare = pool.accWETHPerShare;
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        uint256 total = lpSupply.add(pool.totalRP);
        if (block.timestamp > pool.lastRewardTime && lpSupply != 0) {
            uint256 multiplier = getMultiplier(pool.lastRewardTime, block.timestamp);
            uint256 WETHReward = multiplier.mul(WETHPerSecond).mul(pool.allocPoint).div(totalAllocPoint);
            accWETHPerShare = accWETHPerShare.add(WETHReward.mul(1e12).div(total));
        }
        uint256 userPoint = user.amount.add(user.RPamount);
        return userPoint.mul(accWETHPerShare).div(1e12).sub(user.rewardDebt);
    }

    function pendingRP(uint256 _pid, address _user) external view returns (uint256) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accRPPerShare = pool.accRPPerShare;
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        uint256 total = lpSupply.add(pool.totalRP);
        if (block.timestamp > pool.lastRewardTime && lpSupply != 0) {
            uint256 multiplier = getMultiplier(pool.lastRewardTime, block.timestamp);
            uint256 RPReward = multiplier.mul(RPPerSecond).mul(pool.allocPoint).div(totalAllocPoint);
            accRPPerShare = accRPPerShare.add(RPReward.mul(1e12).div(total));
        }
        uint256 userPoint = user.amount.add(user.RPamount);
        return userPoint.mul(accRPPerShare).div(1e12).sub(user.RPrewardDebt);
    }

    // Update reward variables for all pools. Be careful of gas spending!
    function massUpdatePools() public {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            updatePool(pid);
        }
    }

    // Update reward variables of the given pool to be up-to-date.
    function updatePool(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.timestamp <= pool.lastRewardTime) {
            return;
        }
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        uint256 total = lpSupply.add(pool.totalRP);
        if (lpSupply == 0) {
            pool.lastRewardTime = block.timestamp;
            return;
        }
        uint256 multiplier = getMultiplier(pool.lastRewardTime, block.timestamp);
        uint256 WETHReward = multiplier.mul(WETHPerSecond).mul(pool.allocPoint).div(totalAllocPoint);
        uint256 RPReward = multiplier.mul(RPPerSecond).mul(pool.allocPoint).div(totalAllocPoint);
        pool.accWETHPerShare = pool.accWETHPerShare.add(WETHReward.mul(1e12).div(total));
        pool.accRPPerShare = pool.accRPPerShare.add(RPReward.mul(1e12).div(total));
        pool.lastRewardTime = block.timestamp;
    }

    // Deposit LP tokens to MasterChef for WETH allocation.
    function deposit(uint256 _pid, uint256 _amount) public nonReentrant {

        uint256 fee = _amount.mul(10).div(10000);
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];

        updatePool(_pid);
        
        uint256 userPoint = user.amount.add(user.RPamount); 
        uint256 pending = userPoint.mul(pool.accWETHPerShare).div(1e12).sub(user.rewardDebt);
        uint256 RPpending = userPoint.mul(pool.accRPPerShare).div(1e12).sub(user.RPrewardDebt);

        user.amount = user.amount.add(_amount).sub(fee);
        user.RPamount = user.RPamount.add(RPpending);

        userPoint = user.amount.add(user.RPamount); 
        user.rewardDebt = userPoint.mul(pool.accWETHPerShare).div(1e12);
        user.RPrewardDebt = userPoint.mul(pool.accRPPerShare).div(1e12);

        pool.totalRP = pool.totalRP.add(RPpending);

        if(pending > 0) {
            safeWETHTransfer(msg.sender, pending);
        }
        pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
        pool.lpToken.safeTransfer(owner(), fee);
        emit Deposit(msg.sender, _pid, _amount);
    }

    // Withdraw LP tokens from MasterChef.
    function withdraw(uint256 _pid, uint256 _amount) public nonReentrant {  
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];

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

        updatePool(_pid);

        uint256 userPoint = user.amount.add(user.RPamount); 
        uint256 pending = userPoint.mul(pool.accWETHPerShare).div(1e12).sub(user.rewardDebt);

        user.amount = user.amount.sub(_amount);

        if (_amount > 0) {
            pool.totalRP = pool.totalRP.sub(user.RPamount);
            user.RPamount = 0;
        }
        userPoint = user.amount.add(user.RPamount); 
        user.rewardDebt = userPoint.mul(pool.accWETHPerShare).div(1e12);
        user.RPrewardDebt = userPoint.mul(pool.accRPPerShare).div(1e12);

        if(pending > 0) {
            safeWETHTransfer(msg.sender, pending);
        }
        pool.lpToken.safeTransfer(address(msg.sender), _amount);
        
        emit Withdraw(msg.sender, _pid, _amount);
    }

    // Safe WETH transfer function, just in case if rounding error causes pool to not have enough WETHs.
    function safeWETHTransfer(address _to, uint256 _amount) internal {
        uint256 WETHBal = WETH.balanceOf(address(this));
        if (_amount > WETHBal) {
            WETH.transfer(_to, WETHBal);
        } else {
            WETH.transfer(_to, _amount);
        }
    }

    function updateTeam(address _team, address _team2, address _team3, address _team4) external onlyOwner {
        teamD = _team;
        teamD2 = _team2;
        teamD3 = _team3;
        teamD4 = _team4;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint256","name":"_WETHPerSecond","type":"uint256"},{"internalType":"uint256","name":"_RPPerSecond","type":"uint256"},{"internalType":"uint256","name":"_startTime","type":"uint256"}],"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"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"MaxAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"RPPerSecond","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WETH","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WETHPerSecond","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IERC20","name":"_lpToken","type":"address"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"closeWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","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":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxWETHPerSecond","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"openWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingRP","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingWETH","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"lpToken","type":"address"},{"internalType":"uint256","name":"totalRP","type":"uint256"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardTime","type":"uint256"},{"internalType":"uint256","name":"accWETHPerShare","type":"uint256"},{"internalType":"uint256","name":"accRPPerShare","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":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_RPPerSecond","type":"uint256"}],"name":"setRPPerSecond","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_WETHPerSecond","type":"uint256"}],"name":"setWETHPerSecond","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"supplyRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalWETHdistributed","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":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_team","type":"address"},{"internalType":"address","name":"_team2","type":"address"},{"internalType":"address","name":"_team3","type":"address"},{"internalType":"address","name":"_team4","type":"address"}],"name":"updateTeam","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"RPamount","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"},{"internalType":"uint256","name":"RPrewardDebt","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"},{"inputs":[],"name":"withdrawable","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]

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

0x608060405234801561001057600080fd5b50600436106101da5760003560e01c8063643547a3116101045780639112f2b2116100a2578063b9ac968611610071578063b9ac968614610439578063e2bbb15814610442578063f2fde38b14610455578063f4b83c4c1461046857600080fd5b80639112f2b2146103a457806393f1a40b146103b35780639bd16d7b14610413578063ad5c46481461042657600080fd5b80637b020dad116100de5780637b020dad1461035c578063845105e2146103645780638da5cb5b1461036c5780638dbb1e3a1461039157600080fd5b8063643547a31461031a578063715018a61461032d57806378e979251461033557600080fd5b80631ec3cec31161017c578063441a3e701161014b578063441a3e70146102cf57806350188301146102e257806351eb05a6146102ff578063630b5ba11461031257600080fd5b80631ec3cec31461028d5780632377b2a8146102a05780632b8bbbe8146102b357806341249061146102c657600080fd5b80631526fe27116101b85780631526fe271461021457806317caf6f11461025e5780631ab06ee5146102675780631dce8b421461027a57600080fd5b80630332e936146101df578063081e3eda146101f457806311df43351461020b575b600080fd5b6101f26101ed366004611b53565b610471565b005b600a545b6040519081526020015b60405180910390f35b6101f860085481565b610227610222366004611b53565b6104ed565b604080516001600160a01b0390971687526020870195909552938501929092526060840152608083015260a082015260c001610202565b6101f8600c5481565b6101f2610275366004611b6c565b61053d565b6101f2610288366004611ba3565b61060f565b6101f861029b366004611bff565b610667565b6101f26102ae366004611b53565b6107ff565b6101f26102c1366004611bff565b610a99565b6101f860075481565b6101f26102dd366004611b6c565b610caf565b600d546102ef9060ff1681565b6040519015158152602001610202565b6101f261030d366004611b53565b610eca565b6101f2611059565b6101f2610328366004611b53565b611080565b6101f2611095565b6101f87f000000000000000000000000000000000000000000000000000000000000000081565b6101f26110a9565b6101f26110bd565b6000546001600160a01b03165b6040516001600160a01b039091168152602001610202565b6101f861039f366004611b6c565b6110d4565b6101f8670de0b6b3a764000081565b6103f36103c1366004611bff565b600b60209081526000928352604080842090915290825290208054600182015460028301546003909301549192909184565b604080519485526020850193909352918301526060820152608001610202565b6101f8610421366004611bff565b611168565b600254610379906001600160a01b031681565b6101f860095481565b6101f2610450366004611b6c565b6112db565b6101f2610463366004611c2f565b6114d8565b6101f8610fa081565b610479611551565b670de0b6b3a76400008111156104e05760405162461bcd60e51b815260206004820152602160248201527f736574574554485065725365636f6e643a20746f6f206d616e792057455448736044820152602160f81b60648201526084015b60405180910390fd5b6104e8611059565b600755565b600a81815481106104fd57600080fd5b60009182526020909120600690910201805460018201546002830154600384015460048501546005909501546001600160a01b0390941695509193909286565b610545611551565b610fa08111156105975760405162461bcd60e51b815260206004820152601c60248201527f6164643a20746f6f206d616e7920616c6c6f6320706f696e747321210000000060448201526064016104d7565b61059f611059565b80600a83815481106105b3576105b3611c4c565b906000526020600020906006020160020154600c546105d29190611c78565b6105dc9190611c8b565b600c8190555080600a83815481106105f6576105f6611c4c565b9060005260206000209060060201600201819055505050565b610617611551565b600380546001600160a01b039586166001600160a01b0319918216179091556004805494861694821694909417909355600580549285169284169290921790915560068054919093169116179055565b600080600a848154811061067d5761067d611c4c565b60009182526020808320878452600b825260408085206001600160a01b03898116875293528085206006949094029091016005810154815492516370a0823160e01b815230600482015291965093949291909116906370a0823190602401602060405180830381865afa1580156106f8573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061071c9190611c9e565b905060006107378560010154836115ab90919063ffffffff16565b905084600301544211801561074b57508115155b156107b75760006107608660030154426110d4565b90506000610793600c5461078d8960020154610787600854876115b790919063ffffffff16565b906115b7565b906115c3565b90506107b26107ab8461078d8464e8d4a510006115b7565b86906115ab565b945050505b835460018501546000916107cb91906115ab565b60038601549091506107f0906107ea64e8d4a5100061078d85896115b7565b906115cf565b96505050505050505b92915050565b610807611551565b60095461081490826115ab565b6009556002546040516323b872dd60e01b8152336004820152306024820152604481018390526001600160a01b03909116906323b872dd906064016020604051808303816000875af115801561086e573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906108929190611cb7565b5060006108a761271061078d846101f46115b7565b60025460035460405163a9059cbb60e01b81526001600160a01b03918216600482015260248101849052929350169063a9059cbb906044016020604051808303816000875af11580156108fe573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906109229190611cb7565b506002546004805460405163a9059cbb60e01b81526001600160a01b0391821692810192909252602482018490529091169063a9059cbb906044016020604051808303816000875af115801561097c573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906109a09190611cb7565b5060025460055460405163a9059cbb60e01b81526001600160a01b0391821660048201526024810184905291169063a9059cbb906044016020604051808303816000875af11580156109f6573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610a1a9190611cb7565b5060025460065460405163a9059cbb60e01b81526001600160a01b0391821660048201526024810184905291169063a9059cbb906044016020604051808303816000875af1158015610a70573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610a949190611cb7565b505050565b610aa1611551565b610fa0821115610af35760405162461bcd60e51b815260206004820152601c60248201527f6164643a20746f6f206d616e7920616c6c6f6320706f696e747321210000000060448201526064016104d7565b610afc816115db565b610b04611059565b60007f00000000000000000000000000000000000000000000000000000000000000004211610b53577f0000000000000000000000000000000000000000000000000000000000000000610b55565b425b600c54909150610b6590846115ab565b600c556040805160c0810182526001600160a01b039384168152600060208201818152928201958652606082019384526080820181815260a08301828152600a8054600181018255935292517fc65a7bb8d6351c1cf70c95a316cc6a92839c986682d98bc35f958f4883f9d2a8600690930292830180546001600160a01b031916919097161790955591517fc65a7bb8d6351c1cf70c95a316cc6a92839c986682d98bc35f958f4883f9d2a983015593517fc65a7bb8d6351c1cf70c95a316cc6a92839c986682d98bc35f958f4883f9d2aa82015590517fc65a7bb8d6351c1cf70c95a316cc6a92839c986682d98bc35f958f4883f9d2ab82015590517fc65a7bb8d6351c1cf70c95a316cc6a92839c986682d98bc35f958f4883f9d2ac82015590517fc65a7bb8d6351c1cf70c95a316cc6a92839c986682d98bc35f958f4883f9d2ad90910155565b610cb761167f565b6000600a8381548110610ccc57610ccc611c4c565b60009182526020808320868452600b825260408085203386529092529220600181015460069092029092019250831115610d3d5760405162461bcd60e51b81526020600482015260126024820152711dda5d1a191c985dce881b9bdd0819dbdbd960721b60448201526064016104d7565b600d5460ff16610d855760405162461bcd60e51b81526020600482015260136024820152721dda5d1a191c985dc81b9bdd081bdc195b9959606a1b60448201526064016104d7565b610d8e84610eca565b80546001820154600091610da291906115ab565b90506000610dce83600201546107ea64e8d4a5100061078d8860040154876115b790919063ffffffff16565b6001840154909150610de090866115cf565b60018401558415610e055782546001850154610dfb916115cf565b6001850155600083555b82546001840154610e15916115ab565b9150610e3764e8d4a5100061078d8660040154856115b790919063ffffffff16565b60028401556005840154610e579064e8d4a510009061078d9085906115b7565b60038401558015610e6c57610e6c33826116d8565b8354610e82906001600160a01b03163387611806565b604051858152869033907ff279e6a1f5e320cca91135676d9cb6e44ca8a08c0b88342bcdb1144f6511b5689060200160405180910390a350505050610ec660018055565b5050565b6000600a8281548110610edf57610edf611c4c565b9060005260206000209060060201905080600301544211610efe575050565b80546040516370a0823160e01b81523060048201526000916001600160a01b0316906370a0823190602401602060405180830381865afa158015610f46573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610f6a9190611c9e565b90506000610f858360010154836115ab90919063ffffffff16565b905081600003610f9b5750504260039091015550565b6000610fab8460030154426110d4565b90506000610fd2600c5461078d8760020154610787600754876115b790919063ffffffff16565b90506000610ff9600c5461078d8860020154610787600854886115b790919063ffffffff16565b905061101c6110118561078d8564e8d4a510006115b7565b6004880154906115ab565b60048701556110426110378561078d8464e8d4a510006115b7565b6005880154906115ab565b600587015550504260039094019390935550505050565b600a5460005b81811015610ec65761107081610eca565b61107981611cd9565b905061105f565b611088611551565b611090611059565b600855565b61109d611551565b6110a76000611869565b565b6110b1611551565b600d805460ff19169055565b6110c5611551565b600d805460ff19166001179055565b60007f00000000000000000000000000000000000000000000000000000000000000008311611123577f0000000000000000000000000000000000000000000000000000000000000000611125565b825b92507f0000000000000000000000000000000000000000000000000000000000000000821015611157575060006107f9565b6111618383611c78565b9392505050565b600080600a848154811061117e5761117e611c4c565b60009182526020808320878452600b825260408085206001600160a01b0389811687529352808520600460069590950290920184810154815492516370a0823160e01b8152309681019690965290965091949193919216906370a0823190602401602060405180830381865afa1580156111fc573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906112209190611c9e565b9050600061123b8560010154836115ab90919063ffffffff16565b905084600301544211801561124f57508115155b156112a85760006112648660030154426110d4565b9050600061128b600c5461078d8960020154610787600754876115b790919063ffffffff16565b90506112a36107ab8461078d8464e8d4a510006115b7565b945050505b835460018501546000916112bc91906115ab565b60028601549091506107f0906107ea64e8d4a5100061078d85896115b7565b6112e361167f565b60006112f661271061078d84600a6115b7565b90506000600a848154811061130d5761130d611c4c565b60009182526020808320878452600b8252604080852033865290925292206006909102909101915061133e85610eca565b8054600182015460009161135291906115ab565b9050600061137e83600201546107ea64e8d4a5100061078d8860040154876115b790919063ffffffff16565b905060006113aa84600301546107ea64e8d4a5100061078d8960050154886115b790919063ffffffff16565b90506113c7866107ea8987600101546115ab90919063ffffffff16565b600185015583546113d890826115ab565b80855560018501546113e9916115ab565b925061140b64e8d4a5100061078d8760040154866115b790919063ffffffff16565b6002850155600585015461142b9064e8d4a510009061078d9086906115b7565b6003850155600185015461143f90826115ab565b600186015581156114545761145433836116d8565b845461146b906001600160a01b031633308a6118b9565b6114926114806000546001600160a01b031690565b86546001600160a01b03169088611806565b604051878152889033907f90890809c654f11d6e72a28fa60149770a0d11ec6c92319d6ceb2bb0a4ea1a159060200160405180910390a3505050505050610ec660018055565b6114e0611551565b6001600160a01b0381166115455760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b60648201526084016104d7565b61154e81611869565b50565b6000546001600160a01b031633146110a75760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016104d7565b60006111618284611c8b565b60006111618284611cf2565b60006111618284611d09565b60006111618284611c78565b600a5460005b81811015610a9457826001600160a01b0316600a828154811061160657611606611c4c565b60009182526020909120600690910201546001600160a01b03160361166d5760405162461bcd60e51b815260206004820152601c60248201527f6164643a20706f6f6c20616c726561647920657869737473212121210000000060448201526064016104d7565b8061167781611cd9565b9150506115e1565b6002600154036116d15760405162461bcd60e51b815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c0060448201526064016104d7565b6002600155565b6002546040516370a0823160e01b81523060048201526000916001600160a01b0316906370a0823190602401602060405180830381865afa158015611721573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906117459190611c9e565b9050808211156117cd5760025460405163a9059cbb60e01b81526001600160a01b038581166004830152602482018490529091169063a9059cbb906044015b6020604051808303816000875af11580156117a3573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906117c79190611cb7565b50505050565b60025460405163a9059cbb60e01b81526001600160a01b038581166004830152602482018590529091169063a9059cbb90604401611784565b6040516001600160a01b038316602482015260448101829052610a9490849063a9059cbb60e01b906064015b60408051601f198184030181529190526020810180516001600160e01b03166001600160e01b0319909316929092179091526118f1565b600080546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b6040516001600160a01b03808516602483015283166044820152606481018290526117c79085906323b872dd60e01b90608401611832565b6000611946826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b03166119c39092919063ffffffff16565b805190915015610a9457808060200190518101906119649190611cb7565b610a945760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6044820152691bdd081cdd58d8d9595960b21b60648201526084016104d7565b60606119d284846000856119da565b949350505050565b606082471015611a3b5760405162461bcd60e51b815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f6044820152651c8818d85b1b60d21b60648201526084016104d7565b600080866001600160a01b03168587604051611a579190611d4f565b60006040518083038185875af1925050503d8060008114611a94576040519150601f19603f3d011682016040523d82523d6000602084013e611a99565b606091505b5091509150611aaa87838387611ab5565b979650505050505050565b60608315611b24578251600003611b1d576001600160a01b0385163b611b1d5760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e747261637400000060448201526064016104d7565b50816119d2565b6119d28383815115611b395781518083602001fd5b8060405162461bcd60e51b81526004016104d79190611d6b565b600060208284031215611b6557600080fd5b5035919050565b60008060408385031215611b7f57600080fd5b50508035926020909101359150565b6001600160a01b038116811461154e57600080fd5b60008060008060808587031215611bb957600080fd5b8435611bc481611b8e565b93506020850135611bd481611b8e565b92506040850135611be481611b8e565b91506060850135611bf481611b8e565b939692955090935050565b60008060408385031215611c1257600080fd5b823591506020830135611c2481611b8e565b809150509250929050565b600060208284031215611c4157600080fd5b813561116181611b8e565b634e487b7160e01b600052603260045260246000fd5b634e487b7160e01b600052601160045260246000fd5b818103818111156107f9576107f9611c62565b808201808211156107f9576107f9611c62565b600060208284031215611cb057600080fd5b5051919050565b600060208284031215611cc957600080fd5b8151801515811461116157600080fd5b600060018201611ceb57611ceb611c62565b5060010190565b80820281158282048414176107f9576107f9611c62565b600082611d2657634e487b7160e01b600052601260045260246000fd5b500490565b60005b83811015611d46578181015183820152602001611d2e565b50506000910152565b60008251611d61818460208701611d2b565b9190910192915050565b6020815260008251806020840152611d8a816040850160208701611d2b565b601f01601f1916919091016040019291505056fea2646970667358221220156a25556c847bb83599a1a1e1889799e5082cf5964a693dfc5beda4e0c45e1564736f6c63430008120033

000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _WETHPerSecond (uint256): 0
Arg [1] : _RPPerSecond (uint256): 0
Arg [2] : _startTime (uint256): 0

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000000

35851:12432:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39654:435;;;;;;:::i;:::-;;:::i;:::-;;39402:95;39474:8;:15;39402:95;;;345:25:1;;;333:2;318:18;39402:95:0;;;;;;;;37657:26;;;;;;37957;;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;700:32:1;;;682:51;;764:2;749:18;;742:34;;;;792:18;;;785:34;;;;850:2;835:18;;828:34;893:3;878:19;;871:35;720:3;922:19;;915:35;669:3;654:19;37957:26:0;381:575:1;38200:34:0;;;;;;41552:323;;;;;;:::i;:::-;;:::i;48068:212::-;;;;;;:::i;:::-;;:::i;43136:857::-;;;;;;:::i;:::-;;:::i;38961:433::-;;;;;;:::i;:::-;;:::i;40783:673::-;;;;;;:::i;:::-;;:::i;37622:28::-;;;;;;46564:1104;;;;;;:::i;:::-;;:::i;38332:32::-;;;;;;;;;;;;2845:14:1;;2838:22;2820:41;;2808:2;2793:18;38332:32:0;2680:187:1;44332:928:0;;;;;;:::i;:::-;;:::i;44076:180::-;;;:::i;40097:336::-;;;;;;:::i;:::-;;:::i;8750:103::-;;;:::i;38289:34::-;;;;;38871:82;;;:::i;38775:80::-;;;:::i;8102:87::-;8148:7;8175:6;-1:-1:-1;;;;;8175:6:0;8102:87;;;-1:-1:-1;;;;;3036:32:1;;;3018:51;;3006:2;2991:18;8102:87:0;2872:203:1;41951:240:0;;;;;;:::i;:::-;;:::i;37821:47::-;;37864:4;37821:47;;38039:66;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3311:25:1;;;3367:2;3352:18;;3345:34;;;;3395:18;;;3388:34;3453:2;3438:18;;3431:34;3298:3;3283:19;38039:66:0;3080:391:1;42255:873:0;;;;;;:::i;:::-;;:::i;37398:71::-;;;;;-1:-1:-1;;;;;37398:71:0;;;37692:39;;;;;;45329:1183;;;;;;:::i;:::-;;:::i;9008:201::-;;;;;;:::i;:::-;;:::i;37877:44::-;;37917:4;37877:44;;39654:435;7988:13;:11;:13::i;:::-;37864:4:::1;39742:14;:34;;39734:80;;;::::0;-1:-1:-1;;;39734:80:0;;4152:2:1;39734:80:0::1;::::0;::::1;4134:21:1::0;4191:2;4171:18;;;4164:30;4230:34;4210:18;;;4203:62;-1:-1:-1;;;4281:18:1;;;4274:31;4322:19;;39734:80:0::1;;;;;;;;;40020:17;:15;:17::i;:::-;40051:13;:30:::0;39654:435::o;37957:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;37957:26:0;;;;-1:-1:-1;37957:26:0;;;;;:::o;41552:323::-;7988:13;:11;:13::i;:::-;37917:4:::1;41638:11;:28;;41630:69;;;::::0;-1:-1:-1;;;41630:69:0;;4554:2:1;41630:69:0::1;::::0;::::1;4536:21:1::0;4593:2;4573:18;;;4566:30;4632;4612:18;;;4605:58;4680:18;;41630:69:0::1;4352:352:1::0;41630:69:0::1;41712:17;:15;:17::i;:::-;41806:11;41778:8;41787:4;41778:14;;;;;;;;:::i;:::-;;;;;;;;;;;:25;;;41760:15;;:43;;;;:::i;:::-;:57;;;;:::i;:::-;41742:15;:75;;;;41856:11;41828:8;41837:4;41828:14;;;;;;;;:::i;:::-;;;;;;;;;;;:25;;:39;;;;41552:323:::0;;:::o;48068:212::-;7988:13;:11;:13::i;:::-;48181:5:::1;:13:::0;;-1:-1:-1;;;;;48181:13:0;;::::1;-1:-1:-1::0;;;;;;48181:13:0;;::::1;;::::0;;;48205:6:::1;:15:::0;;;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;;48231:6:::1;:15:::0;;;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;;48257:6:::1;:15:::0;;;;;::::1;::::0;::::1;;::::0;;48068:212::o;43136:857::-;43207:7;43227:21;43251:8;43260:4;43251:14;;;;;;;;:::i;:::-;;;;;;;;;43300;;;:8;:14;;;;;;-1:-1:-1;;;;;43300:21:0;;;;;;;;;;43251:14;;;;;;;;43356:18;;;;43404:12;;:37;;-1:-1:-1;;;43404:37:0;;43435:4;43404:37;;;3018:51:1;43251:14:0;;-1:-1:-1;43300:21:0;;43251:14;43404:12;;;;;:22;;2991:18:1;;43404:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;43385:56;;43452:13;43468:26;43481:4;:12;;;43468:8;:12;;:26;;;;:::i;:::-;43452:42;;43527:4;:19;;;43509:15;:37;:54;;;;-1:-1:-1;43550:13:0;;;43509:54;43505:341;;;43580:18;43601:51;43615:4;:19;;;43636:15;43601:13;:51::i;:::-;43580:72;;43667:16;43686:69;43739:15;;43686:48;43718:4;:15;;;43686:27;43701:11;;43686:10;:14;;:27;;;;:::i;:::-;:31;;:48::i;:::-;:52;;:69::i;:::-;43667:88;-1:-1:-1;43786:48:0;43804:29;43827:5;43804:18;43667:88;43817:4;43804:12;:18::i;:29::-;43786:13;;:17;:48::i;:::-;43770:64;;43565:281;;43505:341;43892:13;;43876:11;;;;43856:17;;43876:30;;:11;:15;:30::i;:::-;43967:17;;;;43856:50;;-1:-1:-1;43924:61:0;;:38;43957:4;43924:28;43856:50;43938:13;43924;:28::i;:38::-;:42;;:61::i;:::-;43917:68;;;;;;;;43136:857;;;;;:::o;38961:433::-;7988:13;:11;:13::i;:::-;39054:20:::1;::::0;:33:::1;::::0;39079:7;39054:24:::1;:33::i;:::-;39031:20;:56:::0;39098:4:::1;::::0;:53:::1;::::0;-1:-1:-1;;;39098:53:0;;39116:10:::1;39098:53;::::0;::::1;5665:34:1::0;39136:4:0::1;5715:18:1::0;;;5708:43;5767:18;;;5760:34;;;-1:-1:-1;;;;;39098:4:0;;::::1;::::0;:17:::1;::::0;5600:18:1;;39098:53:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;39162:18:0::1;39183:27;39204:5;39183:16;:7:::0;39195:3:::1;39183:11;:16::i;:27::-;39222:4;::::0;39236:5:::1;::::0;39222:32:::1;::::0;-1:-1:-1;;;39222:32:0;;-1:-1:-1;;;;;39236:5:0;;::::1;39222:32;::::0;::::1;6261:51:1::0;6328:18;;;6321:34;;;39162:48:0;;-1:-1:-1;39222:4:0::1;::::0;:13:::1;::::0;6234:18:1;;39222:32:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;39265:4:0::1;::::0;39279:6:::1;::::0;;39265:33:::1;::::0;-1:-1:-1;;;39265:33:0;;-1:-1:-1;;;;;39279:6:0;;::::1;39265:33:::0;;::::1;6261:51:1::0;;;;6328:18;;;6321:34;;;39265:4:0;;::::1;::::0;:13:::1;::::0;6234:18:1;;39265:33:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;39309:4:0::1;::::0;39323:6:::1;::::0;39309:33:::1;::::0;-1:-1:-1;;;39309:33:0;;-1:-1:-1;;;;;39323:6:0;;::::1;39309:33;::::0;::::1;6261:51:1::0;6328:18;;;6321:34;;;39309:4:0;::::1;::::0;:13:::1;::::0;6234:18:1;;39309:33:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;39353:4:0::1;::::0;39367:6:::1;::::0;39353:33:::1;::::0;-1:-1:-1;;;39353:33:0;;-1:-1:-1;;;;;39367:6:0;;::::1;39353:33;::::0;::::1;6261:51:1::0;6328:18;;;6321:34;;;39353:4:0;::::1;::::0;:13:::1;::::0;6234:18:1;;39353:33:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;39020:374;38961:433:::0;:::o;40783:673::-;7988:13;:11;:13::i;:::-;37917:4:::1;40872:11;:28;;40864:69;;;::::0;-1:-1:-1;;;40864:69:0;;4554:2:1;40864:69:0::1;::::0;::::1;4536:21:1::0;4593:2;4573:18;;;4566:30;4632;4612:18;;;4605:58;4680:18;;40864:69:0::1;4352:352:1::0;40864:69:0::1;40946:27;40964:8;40946:17;:27::i;:::-;41025:17;:15;:17::i;:::-;41055:22;41098:9;41080:15;:27;:57;;41128:9;41080:57;;;41110:15;41080:57;41166:15;::::0;41055:82;;-1:-1:-1;41166:32:0::1;::::0;41186:11;41166:19:::1;:32::i;:::-;41148:15;:50:::0;41223:224:::1;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;41223:224:0;;::::1;::::0;;-1:-1:-1;41223:224:0::1;::::0;::::1;::::0;;;;;;;;;;;;;;;;;;;;;;;;;;;41209:8:::1;:239:::0;;::::1;::::0;::::1;::::0;;;;;;;::::1;::::0;;::::1;::::0;;::::1;::::0;;-1:-1:-1;;;;;;41209:239:0::1;::::0;;;::::1;;::::0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40783:673::o;46564:1104::-;5373:21;:19;:21::i;:::-;46646::::1;46670:8;46679:4;46670:14;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;46719;;;:8:::1;:14:::0;;;;;;46734:10:::1;46719:26:::0;;;;;;;46766:11:::1;::::0;::::1;::::0;46670:14:::1;::::0;;::::1;::::0;;::::1;::::0;-1:-1:-1;46766:22:0;-1:-1:-1;46766:22:0::1;46758:53;;;::::0;-1:-1:-1;;;46758:53:0;;6568:2:1;46758:53:0::1;::::0;::::1;6550:21:1::0;6607:2;6587:18;;;6580:30;-1:-1:-1;;;6626:18:1;;;6619:48;6684:18;;46758:53:0::1;6366:342:1::0;46758:53:0::1;46830:12;::::0;::::1;;46822:44;;;::::0;-1:-1:-1;;;46822:44:0;;6915:2:1;46822:44:0::1;::::0;::::1;6897:21:1::0;6954:2;6934:18;;;6927:30;-1:-1:-1;;;6973:18:1;;;6966:49;7032:18;;46822:44:0::1;6713:343:1::0;46822:44:0::1;46879:16;46890:4;46879:10;:16::i;:::-;46944:13:::0;;46928:11:::1;::::0;::::1;::::0;46908:17:::1;::::0;46928:30:::1;::::0;:11;:15:::1;:30::i;:::-;46908:50;;46970:15;46988:66;47038:4;:15;;;46988:45;47028:4;46988:35;47002:4;:20;;;46988:9;:13;;:35;;;;:::i;:66::-;47081:11;::::0;::::1;::::0;46970:84;;-1:-1:-1;47081:24:0::1;::::0;47097:7;47081:15:::1;:24::i;:::-;47067:11;::::0;::::1;:38:::0;47122:11;;47118:122:::1;;47182:13:::0;;47165:12:::1;::::0;::::1;::::0;:31:::1;::::0;:16:::1;:31::i;:::-;47150:12;::::0;::::1;:46:::0;47227:1:::1;47211:17:::0;;47118:122:::1;47278:13:::0;;47262:11:::1;::::0;::::1;::::0;:30:::1;::::0;:15:::1;:30::i;:::-;47250:42;;47322:45;47362:4;47322:35;47336:4;:20;;;47322:9;:13;;:35;;;;:::i;:45::-;47304:15;::::0;::::1;:63:::0;47412:18:::1;::::0;::::1;::::0;47398:43:::1;::::0;47436:4:::1;::::0;47398:33:::1;::::0;:9;;:13:::1;:33::i;:43::-;47378:17;::::0;::::1;:63:::0;47457:11;;47454:80:::1;;47485:37;47502:10;47514:7;47485:16;:37::i;:::-;47544:12:::0;;:55:::1;::::0;-1:-1:-1;;;;;47544:12:0::1;47578:10;47591:7:::0;47544:25:::1;:55::i;:::-;47625:35;::::0;345:25:1;;;47646:4:0;;47634:10:::1;::::0;47625:35:::1;::::0;333:2:1;318:18;47625:35:0::1;;;;;;;46633:1035;;;;5417:20:::0;4811:1;5937:22;;5754:213;5417:20;46564:1104;;:::o;44332:928::-;44384:21;44408:8;44417:4;44408:14;;;;;;;;:::i;:::-;;;;;;;;;;;44384:38;;44456:4;:19;;;44437:15;:38;44433:77;;44492:7;44332:928;:::o;44433:77::-;44539:12;;:37;;-1:-1:-1;;;44539:37:0;;44570:4;44539:37;;;3018:51:1;44520:16:0;;-1:-1:-1;;;;;44539:12:0;;:22;;2991:18:1;;44539:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;44520:56;;44587:13;44603:26;44616:4;:12;;;44603:8;:12;;:26;;;;:::i;:::-;44587:42;;44644:8;44656:1;44644:13;44640:104;;-1:-1:-1;;44696:15:0;44674:19;;;;:37;-1:-1:-1;44332:928:0:o;44640:104::-;44754:18;44775:51;44789:4;:19;;;44810:15;44775:13;:51::i;:::-;44754:72;;44837:18;44858:71;44913:15;;44858:50;44892:4;:15;;;44858:29;44873:13;;44858:10;:14;;:29;;;;:::i;:71::-;44837:92;;44940:16;44959:69;45012:15;;44959:48;44991:4;:15;;;44959:27;44974:11;;44959:10;:14;;:27;;;;:::i;:69::-;44940:88;-1:-1:-1;45062:57:0;45087:31;45112:5;45087:20;:10;45102:4;45087:14;:20::i;:31::-;45062:20;;;;;:24;:57::i;:::-;45039:20;;;:80;45151:53;45174:29;45197:5;45174:18;:8;45187:4;45174:12;:18::i;:29::-;45151:18;;;;;:22;:53::i;:::-;45130:18;;;:74;-1:-1:-1;;45237:15:0;45215:19;;;;:37;;;;-1:-1:-1;;;;44332:928:0:o;44076:180::-;44138:8;:15;44121:14;44164:85;44192:6;44186:3;:12;44164:85;;;44222:15;44233:3;44222:10;:15::i;:::-;44200:5;;;:::i;:::-;;;44164:85;;40097:336;7988:13;:11;:13::i;:::-;40368:17:::1;:15;:17::i;:::-;40399:11;:26:::0;40097:336::o;8750:103::-;7988:13;:11;:13::i;:::-;8815:30:::1;8842:1;8815:18;:30::i;:::-;8750:103::o:0;38871:82::-;7988:13;:11;:13::i;:::-;38925:12:::1;:20:::0;;-1:-1:-1;;38925:20:0::1;::::0;;38871:82::o;38775:80::-;7988:13;:11;:13::i;:::-;38828:12:::1;:19:::0;;-1:-1:-1;;38828:19:0::1;38843:4;38828:19;::::0;;38775:80::o;41951:240::-;42023:7;42059:9;42051:5;:17;:37;;42079:9;42051:37;;;42071:5;42051:37;42043:45;;42109:9;42103:3;:15;42099:56;;;-1:-1:-1;42142:1:0;42135:8;;42099:56;42172:11;42178:5;42172:3;:11;:::i;:::-;42165:18;41951:240;-1:-1:-1;;;41951:240:0:o;42255:873::-;42328:7;42348:21;42372:8;42381:4;42372:14;;;;;;;;:::i;:::-;;;;;;;;;42421;;;:8;:14;;;;;;-1:-1:-1;;;;;42421:21:0;;;;;;;;;;42479:20;42372:14;;;;;;;;42479:20;;;;42529:12;;:37;;-1:-1:-1;;;42529:37:0;;42560:4;42529:37;;;3018:51:1;;;;42372:14:0;;-1:-1:-1;42421:21:0;;42479:20;;42372:14;;42529:12;;:22;;2991:18:1;;42529:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;42510:56;;42577:13;42593:26;42606:4;:12;;;42593:8;:12;;:26;;;;:::i;:::-;42577:42;;42652:4;:19;;;42634:15;:37;:54;;;;-1:-1:-1;42675:13:0;;;42634:54;42630:351;;;42705:18;42726:51;42740:4;:19;;;42761:15;42726:13;:51::i;:::-;42705:72;;42792:18;42813:71;42868:15;;42813:50;42847:4;:15;;;42813:29;42828:13;;42813:10;:14;;:29;;;;:::i;:71::-;42792:92;-1:-1:-1;42917:52:0;42937:31;42962:5;42937:20;42792:92;42952:4;42937:14;:20::i;42917:52::-;42899:70;;42690:291;;42630:351;43027:13;;43011:11;;;;42991:17;;43011:30;;:11;:15;:30::i;:::-;43104:15;;;;42991:50;;-1:-1:-1;43059:61:0;;:40;43094:4;43059:30;42991:50;43073:15;43059:13;:30::i;45329:1183::-;5373:21;:19;:21::i;:::-;45410:11:::1;45424:26;45444:5;45424:15;:7:::0;45436:2:::1;45424:11;:15::i;:26::-;45410:40;;45461:21;45485:8;45494:4;45485:14;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;45534;;;:8:::1;:14:::0;;;;;;45549:10:::1;45534:26:::0;;;;;;;45485:14:::1;::::0;;::::1;::::0;;::::1;::::0;-1:-1:-1;45573:16:0::1;45543:4:::0;45573:10:::1;:16::i;:::-;45646:13:::0;;45630:11:::1;::::0;::::1;::::0;45610:17:::1;::::0;45630:30:::1;::::0;:11;:15:::1;:30::i;:::-;45610:50;;45672:15;45690:66;45740:4;:15;;;45690:45;45730:4;45690:35;45704:4;:20;;;45690:9;:13;;:35;;;;:::i;:66::-;45672:84;;45767:17;45787:66;45835:4;:17;;;45787:43;45825:4;45787:33;45801:4;:18;;;45787:9;:13;;:33;;;;:::i;:66::-;45767:86;;45880:33;45909:3;45880:24;45896:7;45880:4;:11;;;:15;;:24;;;;:::i;:33::-;45866:11;::::0;::::1;:47:::0;45940:13;;:28:::1;::::0;45958:9;45940:17:::1;:28::i;:::-;45924:44:::0;;;45993:11:::1;::::0;::::1;::::0;:30:::1;::::0;:15:::1;:30::i;:::-;45981:42;;46053:45;46093:4;46053:35;46067:4;:20;;;46053:9;:13;;:35;;;;:::i;:45::-;46035:15;::::0;::::1;:63:::0;46143:18:::1;::::0;::::1;::::0;46129:43:::1;::::0;46167:4:::1;::::0;46129:33:::1;::::0;:9;;:13:::1;:33::i;:43::-;46109:17;::::0;::::1;:63:::0;46200:12:::1;::::0;::::1;::::0;:27:::1;::::0;46217:9;46200:16:::1;:27::i;:::-;46185:12;::::0;::::1;:42:::0;46243:11;;46240:80:::1;;46271:37;46288:10;46300:7;46271:16;:37::i;:::-;46330:12:::0;;:74:::1;::::0;-1:-1:-1;;;;;46330:12:0::1;46368:10;46389:4;46396:7:::0;46330:29:::1;:74::i;:::-;46415:39;46441:7;8148::::0;8175:6;-1:-1:-1;;;;;8175:6:0;;8102:87;46441:7:::1;46415:12:::0;;-1:-1:-1;;;;;46415:12:0::1;::::0;46450:3;46415:25:::1;:39::i;:::-;46470:34;::::0;345:25:1;;;46490:4:0;;46478:10:::1;::::0;46470:34:::1;::::0;333:2:1;318:18;46470:34:0::1;;;;;;;45397:1115;;;;;;5417:20:::0;4811:1;5937:22;;5754:213;9008:201;7988:13;:11;:13::i;:::-;-1:-1:-1;;;;;9097:22:0;::::1;9089:73;;;::::0;-1:-1:-1;;;9089:73:0;;7403:2:1;9089:73:0::1;::::0;::::1;7385:21:1::0;7442:2;7422:18;;;7415:30;7481:34;7461:18;;;7454:62;-1:-1:-1;;;7532:18:1;;;7525:36;7578:19;;9089:73:0::1;7201:402:1::0;9089:73:0::1;9173:28;9192:8;9173:18;:28::i;:::-;9008:201:::0;:::o;8267:132::-;8148:7;8175:6;-1:-1:-1;;;;;8175:6:0;6733:10;8331:23;8323:68;;;;-1:-1:-1;;;8323:68:0;;7810:2:1;8323:68:0;;;7792:21:1;;;7829:18;;;7822:30;7888:34;7868:18;;;7861:62;7940:18;;8323:68:0;7608:356:1;12443:98:0;12501:7;12528:5;12532:1;12528;:5;:::i;13181:98::-;13239:7;13266:5;13270:1;13266;:5;:::i;13580:98::-;13638:7;13665:5;13669:1;13665;:5;:::i;12824:98::-;12882:7;12909:5;12913:1;12909;:5;:::i;40441:267::-;40527:8;:15;40510:14;40553:148;40583:6;40576:4;:13;40553:148;;;40648:8;-1:-1:-1;;;;;40622:34:0;:8;40631:4;40622:14;;;;;;;;:::i;:::-;;;;;;;;;;;;;;:22;-1:-1:-1;;;;;40622:22:0;:34;40614:75;;;;-1:-1:-1;;;40614:75:0;;8566:2:1;40614:75:0;;;8548:21:1;8605:2;8585:18;;;8578:30;8644;8624:18;;;8617:58;8692:18;;40614:75:0;8364:352:1;40614:75:0;40591:6;;;;:::i;:::-;;;;40553:148;;5453:293;4855:1;5587:7;;:19;5579:63;;;;-1:-1:-1;;;5579:63:0;;8923:2:1;5579:63:0;;;8905:21:1;8962:2;8942:18;;;8935:30;9001:33;8981:18;;;8974:61;9052:18;;5579:63:0;8721:355:1;5579:63:0;4855:1;5720:7;:18;5453:293::o;47782:278::-;47876:4;;:29;;-1:-1:-1;;;47876:29:0;;47899:4;47876:29;;;3018:51:1;47858:15:0;;-1:-1:-1;;;;;47876:4:0;;:14;;2991:18:1;;47876:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;47858:47;;47930:7;47920;:17;47916:137;;;47954:4;;:27;;-1:-1:-1;;;47954:27:0;;-1:-1:-1;;;;;6279:32:1;;;47954:27:0;;;6261:51:1;6328:18;;;6321:34;;;47954:4:0;;;;:13;;6234:18:1;;47954:27:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;39353:33:::1;39020:374;38961:433:::0;:::o;47916:137::-;48014:4;;:27;;-1:-1:-1;;;48014:27:0;;-1:-1:-1;;;;;6279:32:1;;;48014:27:0;;;6261:51:1;6328:18;;;6321:34;;;48014:4:0;;;;:13;;6234:18:1;;48014:27:0;6087:274:1;31994:211:0;32138:58;;-1:-1:-1;;;;;6279:32:1;;32138:58:0;;;6261:51:1;6328:18;;;6321:34;;;32111:86:0;;32131:5;;-1:-1:-1;;;32161:23:0;6234:18:1;;32138:58:0;;;;-1:-1:-1;;32138:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;32138:58:0;-1:-1:-1;;;;;;32138:58:0;;;;;;;;;;32111:19;:86::i;9369:191::-;9443:16;9462:6;;-1:-1:-1;;;;;9479:17:0;;;-1:-1:-1;;;;;;9479:17:0;;;;;;9512:40;;9462:6;;;;;;;9512:40;;9443:16;9512:40;9432:128;9369:191;:::o;32213:248::-;32384:68;;-1:-1:-1;;;;;5683:15:1;;;32384:68:0;;;5665:34:1;5735:15;;5715:18;;;5708:43;5767:18;;;5760:34;;;32357:96:0;;32377:5;;-1:-1:-1;;;32407:27:0;5600:18:1;;32384:68:0;5425:375:1;35061:716:0;35485:23;35511:69;35539:4;35511:69;;;;;;;;;;;;;;;;;35519:5;-1:-1:-1;;;;;35511:27:0;;;:69;;;;;:::i;:::-;35595:17;;35485:95;;-1:-1:-1;35595:21:0;35591:179;;35692:10;35681:30;;;;;;;;;;;;:::i;:::-;35673:85;;;;-1:-1:-1;;;35673:85:0;;9283:2:1;35673:85:0;;;9265:21:1;9322:2;9302:18;;;9295:30;9361:34;9341:18;;;9334:62;-1:-1:-1;;;9412:18:1;;;9405:40;9462:19;;35673:85:0;9081:406:1;20598:229:0;20735:12;20767:52;20789:6;20797:4;20803:1;20806:12;20767:21;:52::i;:::-;20760:59;20598:229;-1:-1:-1;;;;20598:229:0:o;21718:455::-;21888:12;21946:5;21921:21;:30;;21913:81;;;;-1:-1:-1;;;21913:81:0;;9694:2:1;21913:81:0;;;9676:21:1;9733:2;9713:18;;;9706:30;9772:34;9752:18;;;9745:62;-1:-1:-1;;;9823:18:1;;;9816:36;9869:19;;21913:81:0;9492:402:1;21913:81:0;22006:12;22020:23;22047:6;-1:-1:-1;;;;;22047:11:0;22066:5;22073:4;22047:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22005:73;;;;22096:69;22123:6;22131:7;22140:10;22152:12;22096:26;:69::i;:::-;22089:76;21718:455;-1:-1:-1;;;;;;;21718:455:0:o;24291:644::-;24476:12;24505:7;24501:427;;;24533:10;:17;24554:1;24533:22;24529:290;;-1:-1:-1;;;;;18136:19:0;;;24743:60;;;;-1:-1:-1;;;24743:60:0;;10648:2:1;24743:60:0;;;10630:21:1;10687:2;10667:18;;;10660:30;10726:31;10706:18;;;10699:59;10775:18;;24743:60:0;10446:353:1;24743:60:0;-1:-1:-1;24840:10:0;24833:17;;24501:427;24883:33;24891:10;24903:12;25638:17;;:21;25634:388;;25870:10;25864:17;25927:15;25914:10;25910:2;25906:19;25899:44;25634:388;25997:12;25990:20;;-1:-1:-1;;;25990: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;961:248::-;1029:6;1037;1090:2;1078:9;1069:7;1065:23;1061:32;1058:52;;;1106:1;1103;1096:12;1058:52;-1:-1:-1;;1129:23:1;;;1199:2;1184:18;;;1171:32;;-1:-1:-1;961:248:1:o;1214:131::-;-1:-1:-1;;;;;1289:31:1;;1279:42;;1269:70;;1335:1;1332;1325:12;1350:671;1436:6;1444;1452;1460;1513:3;1501:9;1492:7;1488:23;1484:33;1481:53;;;1530:1;1527;1520:12;1481:53;1569:9;1556:23;1588:31;1613:5;1588:31;:::i;:::-;1638:5;-1:-1:-1;1695:2:1;1680:18;;1667:32;1708:33;1667:32;1708:33;:::i;:::-;1760:7;-1:-1:-1;1819:2:1;1804:18;;1791:32;1832:33;1791:32;1832:33;:::i;:::-;1884:7;-1:-1:-1;1943:2:1;1928:18;;1915:32;1956:33;1915:32;1956:33;:::i;:::-;1350:671;;;;-1:-1:-1;1350:671:1;;-1:-1:-1;;1350:671:1:o;2026:315::-;2094:6;2102;2155:2;2143:9;2134:7;2130:23;2126:32;2123:52;;;2171:1;2168;2161:12;2123:52;2207:9;2194:23;2184:33;;2267:2;2256:9;2252:18;2239:32;2280:31;2305:5;2280:31;:::i;:::-;2330:5;2320:15;;;2026:315;;;;;:::o;3698:247::-;3757:6;3810:2;3798:9;3789:7;3785:23;3781:32;3778:52;;;3826:1;3823;3816:12;3778:52;3865:9;3852:23;3884:31;3909:5;3884:31;:::i;4709:127::-;4770:10;4765:3;4761:20;4758:1;4751:31;4801:4;4798:1;4791:15;4825:4;4822:1;4815:15;4841:127;4902:10;4897:3;4893:20;4890:1;4883:31;4933:4;4930:1;4923:15;4957:4;4954:1;4947:15;4973:128;5040:9;;;5061:11;;;5058:37;;;5075:18;;:::i;5106:125::-;5171:9;;;5192:10;;;5189:36;;;5205:18;;:::i;5236:184::-;5306:6;5359:2;5347:9;5338:7;5334:23;5330:32;5327:52;;;5375:1;5372;5365:12;5327:52;-1:-1:-1;5398:16:1;;5236:184;-1:-1:-1;5236:184:1:o;5805:277::-;5872:6;5925:2;5913:9;5904:7;5900:23;5896:32;5893:52;;;5941:1;5938;5931:12;5893:52;5973:9;5967:16;6026:5;6019:13;6012:21;6005:5;6002:32;5992:60;;6048:1;6045;6038:12;7061:135;7100:3;7121:17;;;7118:43;;7141:18;;:::i;:::-;-1:-1:-1;7188:1:1;7177:13;;7061:135::o;7969:168::-;8042:9;;;8073;;8090:15;;;8084:22;;8070:37;8060:71;;8111:18;;:::i;8142:217::-;8182:1;8208;8198:132;;8252:10;8247:3;8243:20;8240:1;8233:31;8287:4;8284:1;8277:15;8315:4;8312:1;8305:15;8198:132;-1:-1:-1;8344:9:1;;8142:217::o;9899:250::-;9984:1;9994:113;10008:6;10005:1;10002:13;9994:113;;;10084:11;;;10078:18;10065:11;;;10058:39;10030:2;10023:10;9994:113;;;-1:-1:-1;;10141:1:1;10123:16;;10116:27;9899:250::o;10154:287::-;10283:3;10321:6;10315:13;10337:66;10396:6;10391:3;10384:4;10376:6;10372:17;10337:66;:::i;:::-;10419:16;;;;;10154:287;-1:-1:-1;;10154:287:1:o;10804:396::-;10953:2;10942:9;10935:21;10916:4;10985:6;10979:13;11028:6;11023:2;11012:9;11008:18;11001:34;11044:79;11116:6;11111:2;11100:9;11096:18;11091:2;11083:6;11079:15;11044:79;:::i;:::-;11184:2;11163:15;-1:-1:-1;;11159:29:1;11144:45;;;;11191:2;11140:54;;10804:396;-1:-1:-1;;10804:396:1:o

ipfs://156a25556c847bb83599a1a1e1889799e5082cf5964a693dfc5beda4e0c45e15