Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at blastscan.io on 2024-06-04
*/

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/// @title Wholesome Poker NFT Staking
/// @author Andre Costa @ MyWeb3Startup.com


// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

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

// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

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

/**
 * @dev Interface of the ERC-20 standard as defined in the ERC.
 */
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 value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens 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 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` 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 value) external returns (bool);
}

/**
 * @dev Interface for the optional metadata functions from the ERC-20 standard.
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

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

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

// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;

    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);
}

// OpenZeppelin Contracts v4.4.1 (utils/Address.sol)

pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 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);
            }
        }
    }
}

// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC1155/IERC1155.sol)

pragma solidity ^0.8.19;

/**
 * @dev Required interface of an ERC1155 compliant contract, as defined in the
 * https://eips.ethereum.org/EIPS/eip-1155[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155 is IERC165 {
    /**
     * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
     */
    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);

    /**
     * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
     * transfers.
     */
    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] ids,
        uint256[] values
    );

    /**
     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
     * `approved`.
     */
    event ApprovalForAll(address indexed account, address indexed operator, bool approved);

    /**
     * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
     *
     * If an {URI} event was emitted for `id`, the standard
     * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
     * returned by {IERC1155MetadataURI-uri}.
     */
    event URI(string value, uint256 indexed id);

    /**
     * @dev Returns the amount of tokens of token type `id` owned by `account`.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) external view returns (uint256);

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(
        address[] calldata accounts,
        uint256[] calldata ids
    ) external view returns (uint256[] memory);

    /**
     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the caller.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
     *
     * See {setApprovalForAll}.
     */
    function isApprovedForAll(address account, address operator) external view returns (bool);

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * WARNING: This function can potentially allow a reentrancy attack when transferring tokens
     * to an untrusted contract, when invoking {onERC1155Received} on the receiver.
     * Ensure to follow the checks-effects-interactions pattern and consider employing
     * reentrancy guards when interacting with untrusted contracts.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     *
     * WARNING: This function can potentially allow a reentrancy attack when transferring tokens
     * to an untrusted contract, when invoking {onERC1155BatchReceived} on the receiver.
     * Ensure to follow the checks-effects-interactions pattern and consider employing
     * reentrancy guards when interacting with untrusted contracts.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) external;
}


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)

pragma solidity ^0.8.19;

/**
 * @dev _Available since v3.1._
 */
interface IERC1155Receiver is IERC165 {
    /**
     * @dev Handles the receipt of a single ERC1155 token type. This function is
     * called at the end of a `safeTransferFrom` after the balance has been updated.
     *
     * NOTE: To accept the transfer, this must return
     * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
     * (i.e. 0xf23a6e61, or its own function selector).
     *
     * @param operator The address which initiated the transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param id The ID of the token being transferred
     * @param value The amount of tokens being transferred
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
     */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    /**
     * @dev Handles the receipt of a multiple ERC1155 token types. This function
     * is called at the end of a `safeBatchTransferFrom` after the balances have
     * been updated.
     *
     * NOTE: To accept the transfer(s), this must return
     * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
     * (i.e. 0xbc197c81, or its own function selector).
     *
     * @param operator The address which initiated the batch transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param ids An array containing ids of each token being transferred (order and length must match values array)
     * @param values An array containing amounts of each token being transferred (order and length must match ids array)
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
     */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}


// OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/IERC1155MetadataURI.sol)

pragma solidity ^0.8.19;

/**
 * @dev Interface of the optional ERC1155MetadataExtension interface, as defined
 * in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155MetadataURI is IERC1155 {
    /**
     * @dev Returns the URI for token type `id`.
     *
     * If the `\{id\}` substring is present in the URI, it must be replaced by
     * clients with the actual token type ID.
     */
    function uri(uint256 id) external view returns (string memory);
}



// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.19;

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// OpenZeppelin Contracts (last updated v4.9.0) (utils/StorageSlot.sol)
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.

pragma solidity ^0.8.19;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC1967 implementation slot:
 * ```solidity
 * contract ERC1967 {
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(newImplementation.code.length > 0);
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 *
 * _Available since v4.1 for `address`, `bool`, `bytes32`, `uint256`._
 * _Available since v4.9 for `string`, `bytes`._
 */
library StorageSlot {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    struct StringSlot {
        string value;
    }

    struct BytesSlot {
        bytes value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` with member `value` located at `slot`.
     */
    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.
     */
    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` with member `value` located at `slot`.
     */
    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
     */
    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }
}

// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)

pragma solidity ^0.8.19;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v5.0._
     */
    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 v5.0._
     */
    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 v5.0._
     */
    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 v5.0._
     */
    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 v5.0._
     */
    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 largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
        }
    }
}

// OpenZeppelin Contracts (last updated v4.9.0) (utils/Arrays.sol)

pragma solidity ^0.8.19;

/**
 * @dev Collection of functions related to array types.
 */
library Arrays {
    using StorageSlot for bytes32;

    /**
     * @dev Searches a sorted `array` and returns the first index that contains
     * a value greater or equal to `element`. If no such index exists (i.e. all
     * values in the array are strictly less than `element`), the array length is
     * returned. Time complexity O(log n).
     *
     * `array` is expected to be sorted in ascending order, and to contain no
     * repeated elements.
     */
    function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
        if (array.length == 0) {
            return 0;
        }

        uint256 low = 0;
        uint256 high = array.length;

        while (low < high) {
            uint256 mid = Math.average(low, high);

            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
            // because Math.average rounds down (it does integer division with truncation).
            if (unsafeAccess(array, mid).value > element) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }

        // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
        if (low > 0 && unsafeAccess(array, low - 1).value == element) {
            return low - 1;
        } else {
            return low;
        }
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(address[] storage arr, uint256 pos) internal pure returns (StorageSlot.AddressSlot storage) {
        bytes32 slot;
        // We use assembly to calculate the storage slot of the element at index `pos` of the dynamic array `arr`
        // following https://docs.soliditylang.org/en/v0.8.17/internals/layout_in_storage.html#mappings-and-dynamic-arrays.

        /// @solidity memory-safe-assembly
        assembly {
            mstore(0, arr.slot)
            slot := add(keccak256(0, 0x20), pos)
        }
        return slot.getAddressSlot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(bytes32[] storage arr, uint256 pos) internal pure returns (StorageSlot.Bytes32Slot storage) {
        bytes32 slot;
        // We use assembly to calculate the storage slot of the element at index `pos` of the dynamic array `arr`
        // following https://docs.soliditylang.org/en/v0.8.17/internals/layout_in_storage.html#mappings-and-dynamic-arrays.

        /// @solidity memory-safe-assembly
        assembly {
            mstore(0, arr.slot)
            slot := add(keccak256(0, 0x20), pos)
        }
        return slot.getBytes32Slot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(uint256[] storage arr, uint256 pos) internal pure returns (StorageSlot.Uint256Slot storage) {
        bytes32 slot;
        // We use assembly to calculate the storage slot of the element at index `pos` of the dynamic array `arr`
        // following https://docs.soliditylang.org/en/v0.8.17/internals/layout_in_storage.html#mappings-and-dynamic-arrays.

        /// @solidity memory-safe-assembly
        assembly {
            mstore(0, arr.slot)
            slot := add(keccak256(0, 0x20), pos)
        }
        return slot.getUint256Slot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeMemoryAccess(uint256[] memory arr, uint256 pos) internal pure returns (uint256 res) {
        assembly {
            res := mload(add(add(arr, 0x20), mul(pos, 0x20)))
        }
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeMemoryAccess(address[] memory arr, uint256 pos) internal pure returns (address res) {
        assembly {
            res := mload(add(add(arr, 0x20), mul(pos, 0x20)))
        }
    }
}

pragma solidity ^0.8.19;

/**
 * @dev Standard ERC20 Errors
 * Interface of the ERC6093 custom errors for ERC20 tokens
 * as defined in https://eips.ethereum.org/EIPS/eip-6093
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC721 Errors
 * Interface of the ERC6093 custom errors for ERC721 tokens
 * as defined in https://eips.ethereum.org/EIPS/eip-6093
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC1155 Errors
 * Interface of the ERC6093 custom errors for ERC1155 tokens
 * as defined in https://eips.ethereum.org/EIPS/eip-6093
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155InsufficientApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

/**
 * @dev Implementation of the basic standard multi-token.
 * See https://eips.ethereum.org/EIPS/eip-1155
 * Originally based on code by Enjin: https://github.com/enjin/erc-1155
 *
 * _Available since v3.1._
 */
abstract contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI, IERC1155Errors {
    using Arrays for uint256[];
    using Arrays for address[];

    string public name = "TiltedKings";
    string public symbol = "xTILTEDKING";

    // Mapping from token ID to account balances
    mapping(uint256 => mapping(address => uint256)) private _balances;

    // Mapping from account to operator approvals
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    // Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
    string internal _uri;

    /**
     * @dev See {_setURI}.
     */
    constructor(/*string memory uri_*/) {
        // _setURI(uri_);
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return
            interfaceId == type(IERC1155).interfaceId ||
            interfaceId == type(IERC1155MetadataURI).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC1155MetadataURI-uri}.
     *
     * This implementation returns the same URI for *all* token types. It relies
     * on the token type ID substitution mechanism
     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
     *
     * Clients calling this function must replace the `\{id\}` substring with the
     * actual token type ID.
     */
    function uri(uint256) public view virtual returns (string memory) {
        return _uri;
    }

    /**
     * @dev See {IERC1155-balanceOf}.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) public view virtual returns (uint256) {
        return _balances[id][account];
    }

    /**
     * @dev See {IERC1155-balanceOfBatch}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(
        address[] memory accounts,
        uint256[] memory ids
    ) public view virtual returns (uint256[] memory) {
        if (accounts.length != ids.length) {
            revert ERC1155InvalidArrayLength(ids.length, accounts.length);
        }

        uint256[] memory batchBalances = new uint256[](accounts.length);

        for (uint256 i = 0; i < accounts.length; ++i) {
            batchBalances[i] = balanceOf(accounts.unsafeMemoryAccess(i), ids.unsafeMemoryAccess(i));
        }

        return batchBalances;
    }

    /**
     * @dev See {IERC1155-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC1155-isApprovedForAll}.
     */
    function isApprovedForAll(address account, address operator) public view virtual returns (bool) {
        return _operatorApprovals[account][operator];
    }

    /**
     * @dev See {IERC1155-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes memory data) public virtual {
        if (from != _msgSender() && !isApprovedForAll(from, _msgSender())) {
            revert ERC1155InsufficientApprovalForAll(_msgSender(), from);
        }
        _safeTransferFrom(from, to, id, amount, data);
    }

    /**
     * @dev See {IERC1155-safeBatchTransferFrom}.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) public virtual {
        if (from != _msgSender() && !isApprovedForAll(from, _msgSender())) {
            revert ERC1155InsufficientApprovalForAll(_msgSender(), from);
        }
        _safeBatchTransferFrom(from, to, ids, amounts, data);
    }

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`. Will mint (or burn) if `from` (or `to`) is the zero address.
     *
     * Emits a {TransferSingle} event if the arrays contain one element, and {TransferBatch} otherwise.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement either {IERC1155Receiver-onERC1155Received}
     *   or {IERC1155Receiver-onERC1155BatchReceived} and return the acceptance magic value.
     */
    function _update(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        if (ids.length != amounts.length) {
            revert ERC1155InvalidArrayLength(ids.length, amounts.length);
        }

        address operator = _msgSender();

        for (uint256 i = 0; i < ids.length; ++i) {
            uint256 id = ids.unsafeMemoryAccess(i);
            uint256 amount = amounts.unsafeMemoryAccess(i);

            if (from != address(0)) {
                uint256 fromBalance = _balances[id][from];
                if (fromBalance < amount) {
                    revert ERC1155InsufficientBalance(from, fromBalance, amount, id);
                }
                unchecked {
                    _balances[id][from] = fromBalance - amount;
                }
            }

            if (to != address(0)) {
                _balances[id][to] += amount;
            }
        }

        if (ids.length == 1) {
            uint256 id = ids.unsafeMemoryAccess(0);
            uint256 amount = amounts.unsafeMemoryAccess(0);
            emit TransferSingle(operator, from, to, id, amount);
            if (to != address(0)) {
                _doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
            }
        } else {
            emit TransferBatch(operator, from, to, ids, amounts);
            if (to != address(0)) {
                _doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
            }
        }
    }

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes memory data) internal {
        if (to == address(0)) {
            revert ERC1155InvalidReceiver(address(0));
        }
        if (from == address(0)) {
            revert ERC1155InvalidSender(address(0));
        }
        (uint256[] memory ids, uint256[] memory amounts) = _asSingletonArrays(id, amount);
        _update(from, to, ids, amounts, data);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function _safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal {
        if (to == address(0)) {
            revert ERC1155InvalidReceiver(address(0));
        }
        if (from == address(0)) {
            revert ERC1155InvalidSender(address(0));
        }
        _update(from, to, ids, amounts, data);
    }

    /**
     * @dev Sets a new URI for all token types, by relying on the token type ID
     * substitution mechanism
     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
     *
     * By this mechanism, any occurrence of the `\{id\}` substring in either the
     * URI or any of the amounts in the JSON file at said URI will be replaced by
     * clients with the token type ID.
     *
     * For example, the `https://token-cdn-domain/\{id\}.json` URI would be
     * interpreted by clients as
     * `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json`
     * for token type ID 0x4cce0.
     *
     * See {uri}.
     *
     * Because these URIs cannot be meaningfully represented by the {URI} event,
     * this function emits no events.
     */
    function _setURI(string memory newuri) internal virtual {
        _uri = newuri;
    }

    /**
     * @dev Creates `amount` tokens of token type `id`, and assigns them to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _mint(address to, uint256 id, uint256 amount, bytes memory data) internal {
        if (to == address(0)) {
            revert ERC1155InvalidReceiver(address(0));
        }
        (uint256[] memory ids, uint256[] memory amounts) = _asSingletonArrays(id, amount);
        _update(address(0), to, ids, amounts, data);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function _mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data) internal {
        if (to == address(0)) {
            revert ERC1155InvalidReceiver(address(0));
        }
        _update(address(0), to, ids, amounts, data);
    }

    /**
     * @dev Destroys `amount` tokens of token type `id` from `from`
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `from` must have at least `amount` tokens of token type `id`.
     */
    function _burn(address from, uint256 id, uint256 amount) internal {
        if (from == address(0)) {
            revert ERC1155InvalidSender(address(0));
        }
        (uint256[] memory ids, uint256[] memory amounts) = _asSingletonArrays(id, amount);
        _update(from, address(0), ids, amounts, "");
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     */
    function _burnBatch(address from, uint256[] memory ids, uint256[] memory amounts) internal {
        if (from == address(0)) {
            revert ERC1155InvalidSender(address(0));
        }
        _update(from, address(0), ids, amounts, "");
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
        if (owner == operator) {
            revert ERC1155InvalidOperator(operator);
        }
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    function _doSafeTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) private {
        if (to.code.length > 0) {
            try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
                if (response != IERC1155Receiver.onERC1155Received.selector) {
                    // Tokens rejected
                    revert ERC1155InvalidReceiver(to);
                }
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    // non-ERC1155Receiver implementer
                    revert ERC1155InvalidReceiver(to);
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        }
    }

    function _doSafeBatchTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) private {
        if (to.code.length > 0) {
            try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (
                bytes4 response
            ) {
                if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {
                    // Tokens rejected
                    revert ERC1155InvalidReceiver(to);
                }
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    // non-ERC1155Receiver implementer
                    revert ERC1155InvalidReceiver(to);
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        }
    }

    function _asSingletonArrays(
        uint256 element1,
        uint256 element2
    ) private pure returns (uint256[] memory array1, uint256[] memory array2) {
        /// @solidity memory-safe-assembly
        assembly {
            array1 := mload(0x40)
            mstore(array1, 1)
            mstore(add(array1, 0x20), element1)

            array2 := add(array1, 0x40)
            mstore(array2, 1)
            mstore(add(array2, 0x20), element2)

            mstore(0x40, add(array2, 0x40))
        }
    }
}

// OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol)

pragma solidity ^0.8.20;

/**
 * @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 EIP-1153 (transient storage) is available on the chain you're deploying at,
 * consider using {ReentrancyGuardTransient} instead.
 *
 * 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;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    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
        if (_status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }

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

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == ENTERED;
    }
}

enum YieldMode {
    AUTOMATIC,
    VOID,
    CLAIMABLE
}

enum GasMode {
    VOID,
    CLAIMABLE 
}

interface IBlast{
    // configure
    function configureContract(address contractAddress, YieldMode _yield, GasMode gasMode, address governor) external;
    function configure(YieldMode _yield, GasMode gasMode, address governor) external;

    // base configuration options
    function configureClaimableYield() external;
    function configureClaimableYieldOnBehalf(address contractAddress) external;
    function configureAutomaticYield() external;
    function configureAutomaticYieldOnBehalf(address contractAddress) external;
    function configureVoidYield() external;
    function configureVoidYieldOnBehalf(address contractAddress) external;
    function configureClaimableGas() external;
    function configureClaimableGasOnBehalf(address contractAddress) external;
    function configureVoidGas() external;
    function configureVoidGasOnBehalf(address contractAddress) external;
    function configureGovernor(address _governor) external;
    function configureGovernorOnBehalf(address _newGovernor, address contractAddress) external;

    // claim yield
    function claimYield(address contractAddress, address recipientOfYield, uint256 amount) external returns (uint256);
    function claimAllYield(address contractAddress, address recipientOfYield) external returns (uint256);

    // claim gas
    function claimAllGas(address contractAddress, address recipientOfGas) external returns (uint256);
    function claimGasAtMinClaimRate(address contractAddress, address recipientOfGas, uint256 minClaimRateBips) external returns (uint256);
    function claimMaxGas(address contractAddress, address recipientOfGas) external returns (uint256);
    function claimGas(address contractAddress, address recipientOfGas, uint256 gasToClaim, uint256 gasSecondsToConsume) external returns (uint256);

    // read functions
    function readClaimableYield(address contractAddress) external view returns (uint256);
    function readYieldConfiguration(address contractAddress) external view returns (uint8);
    function readGasParams(address contractAddress) external view returns (uint256 etherSeconds, uint256 etherBalance, uint256 lastUpdated, GasMode);
}

interface IWholesomePokerStaking {
    function ownerOf(uint256 tokenId) external view returns (address);
}

contract WholeSomePokerNFTStaking is IWholesomePokerStaking, ERC1155, Ownable, ReentrancyGuard {

    // A struct to represent the stake details of each staked NFT token.
    struct Stake {
        address staker;              // The address of the user who staked the token.
        uint256 startTimestamp;      // Timestamp when the token was staked.
        uint256 lastClaimTimestamp;  // Timestamp when rewards were last claimed.
        uint256 claimedTokens;       // Total number of tokens claimed.
    }

    mapping(uint256 => Stake) public stakes;            // Mapping of token ID to its stake information.
    mapping(address => uint256) public totalClaimed;    // Total amount a staker has claimed all time
    IERC721 public NFT;                                 // Interface to interact with the NFT contract.
    IERC20Metadata public TOKEN;                        // Interface for the ERC-20 token used for rewards.
    uint256 private rewardPerDay = 1;                   // Daily reward rate per staked token.

    // Enum to manage the operational states of the contract.
    enum ContractState {
        OFF,  // Contract is not accepting stakes.
        OPEN  // Contract is open for staking.
    }
    ContractState public contractState = ContractState.OPEN; // Initial state is set to OPEN.


    constructor() {
        NFT = IERC721(0x586dc1fc22C2ad85651cA127c589ED13459F161d);
        // TOKEN = IERC20Metadata();

        IBlast(0x4300000000000000000000000000000000000002).configureClaimableGas();
    }

    ///
    /// MODIFIERS
    ///

    /**
     * @dev Ensures that a function is called only when the contract is in the specified state.
     * @param requiredState The state in which the function should be callable.
     */
    modifier isContractState(ContractState requiredState) {
        require(contractState == requiredState, "Invalid State!");
        _;
    }

    ///
    /// STAKE
    ///

    /**
     * @dev Allows a user to stake multiple NFT tokens. The contract must be in the OPEN state.
     * @param tokenIds An array of token IDs that the user wants to stake.
     */
    function stake(uint256[] calldata tokenIds) external isContractState(ContractState.OPEN) nonReentrant {
        for (uint256 i = 0; i < tokenIds.length; i++) {
            require(NFT.ownerOf(tokenIds[i]) == msg.sender, "Not The Owner!");
            stakes[tokenIds[i]] = Stake(msg.sender, block.timestamp, block.timestamp, 0);
            NFT.transferFrom(msg.sender, address(this), tokenIds[i]);     
        }

        _mint(msg.sender, 1, tokenIds.length, "");
    }

    /**
     * @dev Allows a user to unstake multiple NFT tokens and claim any accumulated rewards. The contract must be in the OPEN state.
     * @param tokenIds An array of token IDs that the user wants to unstake.
     */
    function unstake(uint256[] calldata tokenIds) external isContractState(ContractState.OPEN) nonReentrant {
        uint256 totalRewards = 0;
        for (uint256 i = 0; i < tokenIds.length; i++) {
            require(stakes[tokenIds[i]].staker == msg.sender, "Not Staker");
            totalRewards += calculateReward(tokenIds[i]);
            delete stakes[tokenIds[i]];
            NFT.transferFrom(address(this), msg.sender, tokenIds[i]);
        }
        totalClaimed[msg.sender] += totalRewards;
        TOKEN.transfer(msg.sender, totalRewards);

        _burn(msg.sender, 1, tokenIds.length);
    }

    /**
     * @dev Allows a user to claim rewards for multiple staked tokens without unstaking them. The contract must be in the OPEN state.
     * @param tokenIds An array of token IDs for which to claim rewards.
     */
    function claim(uint256[] calldata tokenIds) external isContractState(ContractState.OPEN) nonReentrant {
        uint256 totalRewards = 0;
        for (uint i = 0; i < tokenIds.length; i++) {
            require(stakes[tokenIds[i]].staker == msg.sender, "Not Staker!");
            uint256 reward = calculateReward(tokenIds[i]);
            totalRewards += reward;
            stakes[tokenIds[i]].lastClaimTimestamp = block.timestamp;
            stakes[tokenIds[i]].claimedTokens += reward;
        }
        totalClaimed[msg.sender] += totalRewards;
        TOKEN.transfer(msg.sender, totalRewards);
    }

    ///
    /// SETTERS
    ///

    /**
     * @dev Sets the contract's operational state.
     * @param newState The new state to set the contract to (0 for OFF, 1 for OPEN).
     */
    function setContractState(uint256 newState) external onlyOwner {
        require(newState < 2, "Invalid State!");
        contractState = ContractState(newState);
    }

    /**
     * @dev Sets the address of the NFT contract. This can only be called by the contract owner.
     * @param _nftAddress The address of the IERC721Enumerable contract.
     */
    function setNFTAddress(address _nftAddress) external onlyOwner {
        NFT = IERC721(_nftAddress);
    }

    /**
     * @dev Sets the address of the TOKEN contract. This can only be called by the contract owner.
     * @param _tokenAddress The address of the IERC20Metadata contract.
     */
    function setTokenAddress(address _tokenAddress) external onlyOwner {
        TOKEN = IERC20Metadata(_tokenAddress);
    }

    /**
     * @dev Sets the daily reward amount. Only the owner can call this function.
     * @param _rewardPerDay The new reward per day value.
     */
    function setRewardPerDay(uint256 _rewardPerDay) external onlyOwner {
        rewardPerDay = _rewardPerDay;
    }


    ///
    /// VIEWS
    ///

    /**
     * List all the staked tokens owned by the given address.
     * @param owner The owner address to query.
     */
    function listStakedTokensOfOwner(address owner) public view returns (uint256[] memory) {
        uint256 supply = NFT.totalSupply();
        uint256[] memory tokenIds = new uint256[](supply);
        uint256 count = 0;
        for (uint256 tokenId = 0; tokenId < supply; tokenId++) {
            if (stakes[tokenId].staker == owner) {
                tokenIds[count] = tokenId;
                count++;
            }
        }
        return resizeArray(tokenIds, count);
    }

    /**
     * @notice Calculates the accrued rewards for a staked token since its last claim.
     * @dev This function computes rewards based on the number of full days elapsed since the last claim.
     * It multiplies the number of days by the daily reward rate (`rewardPerDay`).
     * The division by `1 days` converts the time difference from seconds to days.
     * @param tokenId The ID of the staked token for which rewards are being calculated.
     * @return uint256 The total accrued reward in tokens. The reward accumulates daily and is calculated as 
     * the number of full days multiplied by the daily reward rate.
     */
    function calculateReward(uint256 tokenId) public view returns(uint256) { 
        return ((block.timestamp - stakes[tokenId].lastClaimTimestamp) / 1 days) * (rewardPerDay * 10 ** TOKEN.decimals());
    }

    /**
     * List the original owner of the staked nft
     * @param tokenId the token id to query
     */
    function ownerOf(uint256 tokenId) external view override returns(address) {
        return stakes[tokenId].staker;
    }


    ///
    /// MISC
    ///

    /**
     * @dev Internal function to resize an array to fit exactly the number of non-zero entries it contains.
     * @param input The original array containing possible zero entries.
     * @param length The true length of meaningful entries in the array.
     * @return The resized array containing only non-zero entries.
     */
    function resizeArray(uint256[] memory input, uint256 length) internal pure returns (uint256[] memory) {
        uint256[] memory output = new uint256[](length);
        for (uint256 i = 0; i < length; i++) {
            output[i] = input[i];
        }
        return output;
    }
    
    /// @notice Withdraws Ether from the contract
    /// @param recipient The address to receive the Ether
    /// @param amount The amount of Ether to withdraw
    function withdrawEther(address recipient, uint256 amount) external onlyOwner nonReentrant {
        require(recipient != address(0), "Invalid Address!");
        require(amount > 0 && address(this).balance >= amount, "Invalid Amount!");

        (bool sent, ) = recipient.call{value: amount}("");
        require(sent, "Failed to send Ether");
    }

    /// @notice Withdraws ERC20 tokens from the contract
    /// @param recipient The address to receive the tokens
    /// @param amount The amount of tokens to withdraw
    /// @param token The address of the token contract
    function withdrawToken(address recipient, uint256 amount, address token) external onlyOwner nonReentrant {
        require(recipient != address(0), "Invalid Address!");
        require(amount > 0, "Invalid Amount!");
        require(token != address(0), "Invalid Token!");

        require(IERC20(token).transfer(recipient, amount), "Unsuccessful Transfer!");
    }

    function claimMyContractsGas(address recipient) external onlyOwner nonReentrant {
        IBlast(0x4300000000000000000000000000000000000002).claimAllGas(address(this), recipient);
    }

    
    
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"ERC1155InsufficientApprovalForAll","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC1155InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC1155InvalidApprover","type":"error"},{"inputs":[{"internalType":"uint256","name":"idsLength","type":"uint256"},{"internalType":"uint256","name":"valuesLength","type":"uint256"}],"name":"ERC1155InvalidArrayLength","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"ERC1155InvalidOperator","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC1155InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC1155InvalidSender","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","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":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"URI","type":"event"},{"inputs":[],"name":"NFT","outputs":[{"internalType":"contract IERC721","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOKEN","outputs":[{"internalType":"contract IERC20Metadata","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"calculateReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"claimMyContractsGas","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"contractState","outputs":[{"internalType":"enum WholeSomePokerNFTStaking.ContractState","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"listStakedTokensOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeBatchTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newState","type":"uint256"}],"name":"setContractState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_nftAddress","type":"address"}],"name":"setNFTAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_rewardPerDay","type":"uint256"}],"name":"setRewardPerDay","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_tokenAddress","type":"address"}],"name":"setTokenAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"stakes","outputs":[{"internalType":"address","name":"staker","type":"address"},{"internalType":"uint256","name":"startTimestamp","type":"uint256"},{"internalType":"uint256","name":"lastClaimTimestamp","type":"uint256"},{"internalType":"uint256","name":"claimedTokens","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"totalClaimed","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":"tokenIds","type":"uint256[]"}],"name":"unstake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawEther","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"token","type":"address"}],"name":"withdrawToken","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

80977:9439:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62487:134;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;61519:310;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;60845:34;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62240:96;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;83155:479;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;86216:123;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;64295:426;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;89833:371;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;62787:567;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;89240:355;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;88268:122;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;85909:108;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;84722:617;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;90212:187;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2757:103;;;:::i;:::-;;81714:18;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;81819:27;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;82222:55;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2109:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;86506:114;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;60886:36;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63427:146;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;86795:488;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;87942:205;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;81505:39;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;83871:616;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;63645:159;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;81611:47;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63876:342;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3015:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;85540:171;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;62487:134;62564:7;62591:9;:13;62601:2;62591:13;;;;;;;;;;;:22;62605:7;62591:22;;;;;;;;;;;;;;;;62584:29;;62487:134;;;;:::o;61519:310::-;61621:4;61673:26;61658:41;;;:11;:41;;;;:110;;;;61731:37;61716:52;;;:11;:52;;;;61658:110;:163;;;;61785:36;61809:11;61785:23;:36::i;:::-;61658:163;61638:183;;61519:310;;;:::o;60845:34::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;62240:96::-;62291:13;62324:4;62317:11;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62240:96;;;:::o;83155:479::-;83224:18;82869:13;82852:30;;;;;;;;:::i;:::-;;:13;;;;;;;;;;;:30;;;;;;;;:::i;:::-;;;82844:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;77641:21:::1;:19;:21::i;:::-;83273:9:::2;83268:305;83292:8;;:15;;83288:1;:19;83268:305;;;83365:10;83337:38;;:3;;;;;;;;;;;:11;;;83349:8;;83358:1;83349:11;;;;;;;:::i;:::-;;;;;;;;83337:24;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:38;;;83329:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;83431:54;;;;;;;;83437:10;83431:54;;;;;;83449:15;83431:54;;;;83466:15;83431:54;;;;83483:1;83431:54;;::::0;83409:6:::2;:19;83416:8;;83425:1;83416:11;;;;;;;:::i;:::-;;;;;;;;83409:19;;;;;;;;;;;:76;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;83500:3;;;;;;;;;;;:16;;;83517:10;83537:4;83544:8;;83553:1;83544:11;;;;;;;:::i;:::-;;;;;;;;83500:56;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;83309:3;;;;;;;83268:305;;;;83585:41;83591:10;83603:1;83606:8;;:15;;83585:41;;;;;;;;;;;::::0;:5:::2;:41::i;:::-;77685:20:::1;:18;:20::i;:::-;83155:479:::0;;;:::o;86216:123::-;1995:13;:11;:13::i;:::-;86317::::1;86294:5;;:37;;;;;;;;;;;;;;;;;;86216:123:::0;:::o;64295:426::-;64509:12;:10;:12::i;:::-;64501:20;;:4;:20;;;;:61;;;;;64526:36;64543:4;64549:12;:10;:12::i;:::-;64526:16;:36::i;:::-;64525:37;64501:61;64497:154;;;64620:12;:10;:12::i;:::-;64634:4;64586:53;;;;;;;;;;;;:::i;:::-;;;;;;;;64497:154;64661:52;64684:4;64690:2;64694:3;64699:7;64708:4;64661:22;:52::i;:::-;64295:426;;;;;:::o;89833:371::-;1995:13;:11;:13::i;:::-;77641:21:::1;:19;:21::i;:::-;89978:1:::2;89957:23;;:9;:23;;::::0;89949:52:::2;;;;;;;;;;;;:::i;:::-;;;;;;;;;90029:1;90020:6;:10;90012:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;90086:1;90069:19;;:5;:19;;::::0;90061:46:::2;;;;;;;;;;;;:::i;:::-;;;;;;;;;90135:5;90128:22;;;90151:9;90162:6;90128:41;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;90120:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;77685:20:::1;:18;:20::i;:::-;89833:371:::0;;;:::o;62787:567::-;62914:16;62966:3;:10;62947:8;:15;:29;62943:123;;63026:3;:10;63038:8;:15;63000:54;;;;;;;;;;;;:::i;:::-;;;;;;;;62943:123;63078:30;63125:8;:15;63111:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63078:63;;63159:9;63154:160;63178:8;:15;63174:1;:19;63154:160;;;63234:68;63244:30;63272:1;63244:8;:27;;:30;;;;:::i;:::-;63276:25;63299:1;63276:3;:22;;:25;;;;:::i;:::-;63234:9;:68::i;:::-;63215:13;63229:1;63215:16;;;;;;;;:::i;:::-;;;;;;;:87;;;;;63195:3;;;;;63154:160;;;;63333:13;63326:20;;;62787:567;;;;:::o;89240:355::-;1995:13;:11;:13::i;:::-;77641:21:::1;:19;:21::i;:::-;89370:1:::2;89349:23;;:9;:23;;::::0;89341:52:::2;;;;;;;;;;;;:::i;:::-;;;;;;;;;89421:1;89412:6;:10;:45;;;;;89451:6;89426:21;:31;;89412:45;89404:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;89491:9;89506;:14;;89528:6;89506:33;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;89490:49;;;89558:4;89550:37;;;;;;;;;;;;:::i;:::-;;;;;;;;;89330:265;77685:20:::1;:18;:20::i;:::-;89240:355:::0;;:::o;88268:122::-;88333:7;88360:6;:15;88367:7;88360:15;;;;;;;;;;;:22;;;;;;;;;;;;88353:29;;88268:122;;;:::o;85909:108::-;1995:13;:11;:13::i;:::-;85997:11:::1;85983:3;;:26;;;;;;;;;;;;;;;;;;85909:108:::0;:::o;84722:617::-;84791:18;82869:13;82852:30;;;;;;;;:::i;:::-;;:13;;;;;;;;;;;:30;;;;;;;;:::i;:::-;;;82844:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;77641:21:::1;:19;:21::i;:::-;84835:20:::2;84875:6:::0;84870:360:::2;84891:8;;:15;;84887:1;:19;84870:360;;;84966:10;84936:40;;:6;:19;84943:8;;84952:1;84943:11;;;;;;;:::i;:::-;;;;;;;;84936:19;;;;;;;;;;;:26;;;;;;;;;;;;:40;;;84928:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;85007:14;85024:28;85040:8;;85049:1;85040:11;;;;;;;:::i;:::-;;;;;;;;85024:15;:28::i;:::-;85007:45;;85083:6;85067:22;;;;;:::i;:::-;;;85145:15;85104:6;:19;85111:8;;85120:1;85111:11;;;;;;;:::i;:::-;;;;;;;;85104:19;;;;;;;;;;;:38;;:56;;;;85212:6;85175;:19;85182:8;;85191:1;85182:11;;;;;;;:::i;:::-;;;;;;;;85175:19;;;;;;;;;;;:33;;;:43;;;;;;;:::i;:::-;;;;;;;;84913:317;84908:3;;;;;;;84870:360;;;;85268:12;85240;:24;85253:10;85240:24;;;;;;;;;;;;;;;;:40;;;;;;;:::i;:::-;;;;;;;;85291:5;;;;;;;;;;;:14;;;85306:10;85318:12;85291:40;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;84824:515;77685:20:::1;:18;:20::i;:::-;84722:617:::0;;;:::o;90212:187::-;1995:13;:11;:13::i;:::-;77641:21:::1;:19;:21::i;:::-;90310:42:::2;90303:62;;;90374:4;90381:9;90303:88;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;77685:20:::1;:18;:20::i;:::-;90212:187:::0;:::o;2757:103::-;1995:13;:11;:13::i;:::-;2822:30:::1;2849:1;2822:18;:30::i;:::-;2757:103::o:0;81714:18::-;;;;;;;;;;;;;:::o;81819:27::-;;;;;;;;;;;;;:::o;82222:55::-;;;;;;;;;;;;;:::o;2109:87::-;2155:7;2182:6;;;;;;;;;;;2175:13;;2109:87;:::o;86506:114::-;1995:13;:11;:13::i;:::-;86599::::1;86584:12;:28;;;;86506:114:::0;:::o;60886:36::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;63427:146::-;63513:52;63532:12;:10;:12::i;:::-;63546:8;63556;63513:18;:52::i;:::-;63427:146;;:::o;86795:488::-;86864:16;86893:14;86910:3;;;;;;;;;;;:15;;;:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;86893:34;;86938:25;86980:6;86966:21;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;86938:49;;86998:13;87031:15;87026:204;87062:6;87052:7;:16;87026:204;;;87126:5;87100:31;;:6;:15;87107:7;87100:15;;;;;;;;;;;:22;;;;;;;;;;;;:31;;;87096:123;;87170:7;87152:8;87161:5;87152:15;;;;;;;;:::i;:::-;;;;;;;:25;;;;;87196:7;;;;;:::i;:::-;;;;87096:123;87070:9;;;;;;;87026:204;;;;87247:28;87259:8;87269:5;87247:11;:28::i;:::-;87240:35;;;;;86795:488;;;:::o;87942:205::-;88004:7;88122:5;;;;;;;;;;;:14;;;:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;88116:2;:22;;;;:::i;:::-;88101:12;;:37;;;;:::i;:::-;88090:6;88052;:15;88059:7;88052:15;;;;;;;;;;;:34;;;88034:15;:52;;;;:::i;:::-;88033:63;;;;:::i;:::-;88032:107;;;;:::i;:::-;88025:114;;87942:205;;;:::o;81505:39::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;83871:616::-;83942:18;82869:13;82852:30;;;;;;;;:::i;:::-;;:13;;;;;;;;;;;:30;;;;;;;;:::i;:::-;;;82844:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;77641:21:::1;:19;:21::i;:::-;83986:20:::2;84026:9:::0;84021:307:::2;84045:8;;:15;;84041:1;:19;84021:307;;;84120:10;84090:40;;:6;:19;84097:8;;84106:1;84097:11;;;;;;;:::i;:::-;;;;;;;;84090:19;;;;;;;;;;;:26;;;;;;;;;;;;:40;;;84082:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;84176:28;84192:8;;84201:1;84192:11;;;;;;;:::i;:::-;;;;;;;;84176:15;:28::i;:::-;84160:44;;;;;:::i;:::-;;;84226:6;:19;84233:8;;84242:1;84233:11;;;;;;;:::i;:::-;;;;;;;;84226:19;;;;;;;;;;;;84219:26:::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;84260:3;;;;;;;;;;;:16;;;84285:4;84292:10;84304:8;;84313:1;84304:11;;;;;;;:::i;:::-;;;;;;;;84260:56;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;84062:3;;;;;;;84021:307;;;;84366:12;84338;:24;84351:10;84338:24;;;;;;;;;;;;;;;;:40;;;;;;;:::i;:::-;;;;;;;;84389:5;;;;;;;;;;;:14;;;84404:10;84416:12;84389:40;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;84442:37;84448:10;84460:1;84463:8;;:15;;84442:5;:37::i;:::-;83975:512;77685:20:::1;:18;:20::i;:::-;83871:616:::0;;;:::o;63645:159::-;63735:4;63759:18;:27;63778:7;63759:27;;;;;;;;;;;;;;;:37;63787:8;63759:37;;;;;;;;;;;;;;;;;;;;;;;;;63752:44;;63645:159;;;;:::o;81611:47::-;;;;;;;;;;;;;;;;;:::o;63876:342::-;64013:12;:10;:12::i;:::-;64005:20;;:4;:20;;;;:61;;;;;64030:36;64047:4;64053:12;:10;:12::i;:::-;64030:16;:36::i;:::-;64029:37;64005:61;64001:154;;;64124:12;:10;:12::i;:::-;64138:4;64090:53;;;;;;;;;;;;:::i;:::-;;;;;;;;64001:154;64165:45;64183:4;64189:2;64193;64197:6;64205:4;64165:17;:45::i;:::-;63876:342;;;;;:::o;3015:201::-;1995:13;:11;:13::i;:::-;3124:1:::1;3104:22;;:8;:22;;::::0;3096:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;3180:28;3199:8;3180:18;:28::i;:::-;3015:201:::0;:::o;85540:171::-;1995:13;:11;:13::i;:::-;85633:1:::1;85622:8;:12;85614:39;;;;;;;;;;;;:::i;:::-;;;;;;;;;85694:8;85680:23;;;;;;;;:::i;:::-;;85664:13;;:39;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;85540:171:::0;:::o;29298:148::-;29374:4;29413:25;29398:40;;;:11;:40;;;;29391:47;;29298:148;;;:::o;77721:315::-;77019:1;77850:7;;:18;77846:88;;77892:30;;;;;;;;;;;;;;77846:88;77019:1;78011:7;:17;;;;77721:315::o;69895:337::-;70007:1;69993:16;;:2;:16;;;69989:90;;70064:1;70033:34;;;;;;;;;;;:::i;:::-;;;;;;;;69989:90;70090:20;70112:24;70140:30;70159:2;70163:6;70140:18;:30::i;:::-;70089:81;;;;70181:43;70197:1;70201:2;70205:3;70210:7;70219:4;70181:7;:43::i;:::-;69978:254;;69895:337;;;;:::o;78044:212::-;76976:1;78227:7;:21;;;;78044:212::o;2274:132::-;2349:12;:10;:12::i;:::-;2338:23;;:7;:5;:7::i;:::-;:23;;;2330:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;2274:132::o;746:98::-;799:7;826:10;819:17;;746:98;:::o;68135:442::-;68350:1;68336:16;;:2;:16;;;68332:90;;68407:1;68376:34;;;;;;;;;;;:::i;:::-;;;;;;;;68332:90;68452:1;68436:18;;:4;:18;;;68432:90;;68507:1;68478:32;;;;;;;;;;;:::i;:::-;;;;;;;;68432:90;68532:37;68540:4;68546:2;68550:3;68555:7;68564:4;68532:7;:37::i;:::-;68135:442;;;;;:::o;53670:201::-;53756:11;53846:4;53841:3;53837:14;53830:4;53825:3;53821:14;53817:35;53811:42;53804:49;;53670:201;;;;:::o;53260:::-;53346:11;53436:4;53431:3;53427:14;53420:4;53415:3;53411:14;53407:35;53401:42;53394:49;;53260:201;;;;:::o;3376:191::-;3450:16;3469:6;;;;;;;;;;;3450:25;;3495:8;3486:6;;:17;;;;;;;;;;;;;;;;;;3550:8;3519:40;;3540:8;3519:40;;;;;;;;;;;;3439:128;3376:191;:::o;72169:314::-;72286:8;72277:17;;:5;:17;;;72273:89;;72341:8;72318:32;;;;;;;;;;;:::i;:::-;;;;;;;;72273:89;72410:8;72372:18;:25;72391:5;72372:25;;;;;;;;;;;;;;;:35;72398:8;72372:35;;;;;;;;;;;;;;;;:46;;;;;;;;;;;;;;;;;;72456:8;72434:41;;72449:5;72434:41;;;72466:8;72434:41;;;;;;:::i;:::-;;;;;;;;72169:314;;;:::o;88777:286::-;88861:16;88890:23;88930:6;88916:21;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;88890:47;;88953:9;88948:84;88972:6;88968:1;:10;88948:84;;;89012:5;89018:1;89012:8;;;;;;;;:::i;:::-;;;;;;;;89000:6;89007:1;89000:9;;;;;;;;:::i;:::-;;;;;;;:20;;;;;88980:3;;;;;;;88948:84;;;;89049:6;89042:13;;;88777:286;;;;:::o;71203:320::-;71300:1;71284:18;;:4;:18;;;71280:90;;71355:1;71326:32;;;;;;;;;;;:::i;:::-;;;;;;;;71280:90;71381:20;71403:24;71431:30;71450:2;71454:6;71431:18;:30::i;:::-;71380:81;;;;71472:43;71480:4;71494:1;71498:3;71503:7;71472:43;;;;;;;;;;;;:7;:43::i;:::-;71269:254;;71203:320;;;:::o;67320:457::-;67458:1;67444:16;;:2;:16;;;67440:90;;67515:1;67484:34;;;;;;;;;;;:::i;:::-;;;;;;;;67440:90;67560:1;67544:18;;:4;:18;;;67540:90;;67615:1;67586:32;;;;;;;;;;;:::i;:::-;;;;;;;;67540:90;67641:20;67663:24;67691:30;67710:2;67714:6;67691:18;:30::i;:::-;67640:81;;;;67732:37;67740:4;67746:2;67750:3;67755:7;67764:4;67732:7;:37::i;:::-;67429:348;;67320:457;;;;;:::o;74580:529::-;74691:23;74716;74836:4;74830:11;74820:21;;74870:1;74862:6;74855:17;74912:8;74905:4;74897:6;74893:17;74886:35;74959:4;74951:6;74947:17;74937:27;;74993:1;74985:6;74978:17;75035:8;75028:4;75020:6;75016:17;75009:35;75085:4;75077:6;75073:17;75067:4;75060:31;74580:529;;;;;:::o;65240:1616::-;65448:7;:14;65434:3;:10;:28;65430:121;;65512:3;:10;65524:7;:14;65486:53;;;;;;;;;;;;:::i;:::-;;;;;;;;65430:121;65563:16;65582:12;:10;:12::i;:::-;65563:31;;65612:9;65607:647;65631:3;:10;65627:1;:14;65607:647;;;65663:10;65676:25;65699:1;65676:3;:22;;:25;;;;:::i;:::-;65663:38;;65716:14;65733:29;65760:1;65733:7;:26;;:29;;;;:::i;:::-;65716:46;;65799:1;65783:18;;:4;:18;;;65779:364;;65822:19;65844:9;:13;65854:2;65844:13;;;;;;;;;;;:19;65858:4;65844:19;;;;;;;;;;;;;;;;65822:41;;65900:6;65886:11;:20;65882:133;;;65965:4;65971:11;65984:6;65992:2;65938:57;;;;;;;;;;;;;;:::i;:::-;;;;;;;;65882:133;66102:6;66088:11;:20;66066:9;:13;66076:2;66066:13;;;;;;;;;;;:19;66080:4;66066:19;;;;;;;;;;;;;;;:42;;;;65803:340;65779:364;66177:1;66163:16;;:2;:16;;;66159:84;;66221:6;66200:9;:13;66210:2;66200:13;;;;;;;;;;;:17;66214:2;66200:17;;;;;;;;;;;;;;;;:27;;;;;;;:::i;:::-;;;;;;;;66159:84;65648:606;;65643:3;;;;;65607:647;;;;66284:1;66270:3;:10;:15;66266:583;;66302:10;66315:25;66338:1;66315:3;:22;;:25;;;;:::i;:::-;66302:38;;66355:14;66372:29;66399:1;66372:7;:26;;:29;;;;:::i;:::-;66355:46;;66452:2;66421:46;;66446:4;66421:46;;66436:8;66421:46;;;66456:2;66460:6;66421:46;;;;;;;:::i;:::-;;;;;;;;66500:1;66486:16;;:2;:16;;;66482:125;;66523:68;66554:8;66564:4;66570:2;66574;66578:6;66586:4;66523:30;:68::i;:::-;66482:125;66287:331;;66266:583;;;66674:2;66644:47;;66668:4;66644:47;;66658:8;66644:47;;;66678:3;66683:7;66644:47;;;;;;;:::i;:::-;;;;;;;;66724:1;66710:16;;:2;:16;;;66706:132;;66747:75;66783:8;66793:4;66799:2;66803:3;66808:7;66817:4;66747:35;:75::i;:::-;66706:132;66266:583;65419:1437;65240:1616;;;;;:::o;72491:1002::-;72723:1;72706:2;:14;;;:18;72702:784;;;72762:2;72745:38;;;72784:8;72794:4;72800:2;72804:6;72812:4;72745:72;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;72741:734;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;73124:1;73107:6;:13;:18;73103:357;;73236:2;73213:26;;;;;;;;;;;:::i;:::-;;;;;;;;73103:357;73410:6;73404:13;73395:6;73391:2;73387:15;73380:38;72741:734;72879:43;;;72867:55;;;:8;:55;;;;72863:177;;73017:2;72994:26;;;;;;;;;;;:::i;:::-;;;;;;;;72863:177;72818:237;72702:784;72491:1002;;;;;;:::o;73501:1071::-;73758:1;73741:2;:14;;;:18;73737:828;;;73797:2;73780:43;;;73824:8;73834:4;73840:3;73845:7;73854:4;73780:79;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;73776:778;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74203:1;74186:6;:13;:18;74182:357;;74315:2;74292:26;;;;;;;;;;;:::i;:::-;;;;;;;;74182:357;74489:6;74483:13;74474:6;74470:2;74466:15;74459:38;73776:778;73953:48;;;73941:60;;;:8;:60;;;;73937:182;;74096:2;74073:26;;;;;;;;;;;:::i;:::-;;;;;;;;73937:182;73860:274;73737:828;73501:1071;;;;;;:::o;7:75:1:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:126;371:7;411:42;404:5;400:54;389:65;;334:126;;;:::o;466:96::-;503:7;532:24;550:5;532:24;:::i;:::-;521:35;;466:96;;;:::o;568:122::-;641:24;659:5;641:24;:::i;:::-;634:5;631:35;621:63;;680:1;677;670:12;621:63;568:122;:::o;696:139::-;742:5;780:6;767:20;758:29;;796:33;823:5;796:33;:::i;:::-;696:139;;;;:::o;841:77::-;878:7;907:5;896:16;;841:77;;;:::o;924:122::-;997:24;1015:5;997:24;:::i;:::-;990:5;987:35;977:63;;1036:1;1033;1026:12;977:63;924:122;:::o;1052:139::-;1098:5;1136:6;1123:20;1114:29;;1152:33;1179:5;1152:33;:::i;:::-;1052:139;;;;:::o;1197:474::-;1265:6;1273;1322:2;1310:9;1301:7;1297:23;1293:32;1290:119;;;1328:79;;:::i;:::-;1290:119;1448:1;1473:53;1518:7;1509:6;1498:9;1494:22;1473:53;:::i;:::-;1463:63;;1419:117;1575:2;1601:53;1646:7;1637:6;1626:9;1622:22;1601:53;:::i;:::-;1591:63;;1546:118;1197:474;;;;;:::o;1677:118::-;1764:24;1782:5;1764:24;:::i;:::-;1759:3;1752:37;1677:118;;:::o;1801:222::-;1894:4;1932:2;1921:9;1917:18;1909:26;;1945:71;2013:1;2002:9;1998:17;1989:6;1945:71;:::i;:::-;1801:222;;;;:::o;2029:149::-;2065:7;2105:66;2098:5;2094:78;2083:89;;2029:149;;;:::o;2184:120::-;2256:23;2273:5;2256:23;:::i;:::-;2249:5;2246:34;2236:62;;2294:1;2291;2284:12;2236:62;2184:120;:::o;2310:137::-;2355:5;2393:6;2380:20;2371:29;;2409:32;2435:5;2409:32;:::i;:::-;2310:137;;;;:::o;2453:327::-;2511:6;2560:2;2548:9;2539:7;2535:23;2531:32;2528:119;;;2566:79;;:::i;:::-;2528:119;2686:1;2711:52;2755:7;2746:6;2735:9;2731:22;2711:52;:::i;:::-;2701:62;;2657:116;2453:327;;;;:::o;2786:90::-;2820:7;2863:5;2856:13;2849:21;2838:32;;2786:90;;;:::o;2882:109::-;2963:21;2978:5;2963:21;:::i;:::-;2958:3;2951:34;2882:109;;:::o;2997:210::-;3084:4;3122:2;3111:9;3107:18;3099:26;;3135:65;3197:1;3186:9;3182:17;3173:6;3135:65;:::i;:::-;2997:210;;;;:::o;3213:99::-;3265:6;3299:5;3293:12;3283:22;;3213:99;;;:::o;3318:169::-;3402:11;3436:6;3431:3;3424:19;3476:4;3471:3;3467:14;3452:29;;3318:169;;;;:::o;3493:139::-;3582:6;3577:3;3572;3566:23;3623:1;3614:6;3609:3;3605:16;3598:27;3493:139;;;:::o;3638:102::-;3679:6;3730:2;3726:7;3721:2;3714:5;3710:14;3706:28;3696:38;;3638:102;;;:::o;3746:377::-;3834:3;3862:39;3895:5;3862:39;:::i;:::-;3917:71;3981:6;3976:3;3917:71;:::i;:::-;3910:78;;3997:65;4055:6;4050:3;4043:4;4036:5;4032:16;3997:65;:::i;:::-;4087:29;4109:6;4087:29;:::i;:::-;4082:3;4078:39;4071:46;;3838:285;3746:377;;;;:::o;4129:313::-;4242:4;4280:2;4269:9;4265:18;4257:26;;4329:9;4323:4;4319:20;4315:1;4304:9;4300:17;4293:47;4357:78;4430:4;4421:6;4357:78;:::i;:::-;4349:86;;4129:313;;;;:::o;4448:329::-;4507:6;4556:2;4544:9;4535:7;4531:23;4527:32;4524:119;;;4562:79;;:::i;:::-;4524:119;4682:1;4707:53;4752:7;4743:6;4732:9;4728:22;4707:53;:::i;:::-;4697:63;;4653:117;4448:329;;;;:::o;4783:117::-;4892:1;4889;4882:12;4906:117;5015:1;5012;5005:12;5029:117;5138:1;5135;5128:12;5169:568;5242:8;5252:6;5302:3;5295:4;5287:6;5283:17;5279:27;5269:122;;5310:79;;:::i;:::-;5269:122;5423:6;5410:20;5400:30;;5453:18;5445:6;5442:30;5439:117;;;5475:79;;:::i;:::-;5439:117;5589:4;5581:6;5577:17;5565:29;;5643:3;5635:4;5627:6;5623:17;5613:8;5609:32;5606:41;5603:128;;;5650:79;;:::i;:::-;5603:128;5169:568;;;;;:::o;5743:559::-;5829:6;5837;5886:2;5874:9;5865:7;5861:23;5857:32;5854:119;;;5892:79;;:::i;:::-;5854:119;6040:1;6029:9;6025:17;6012:31;6070:18;6062:6;6059:30;6056:117;;;6092:79;;:::i;:::-;6056:117;6205:80;6277:7;6268:6;6257:9;6253:22;6205:80;:::i;:::-;6187:98;;;;5983:312;5743:559;;;;;:::o;6308:329::-;6367:6;6416:2;6404:9;6395:7;6391:23;6387:32;6384:119;;;6422:79;;:::i;:::-;6384:119;6542:1;6567:53;6612:7;6603:6;6592:9;6588:22;6567:53;:::i;:::-;6557:63;;6513:117;6308:329;;;;:::o;6643:180::-;6691:77;6688:1;6681:88;6788:4;6785:1;6778:15;6812:4;6809:1;6802:15;6829:281;6912:27;6934:4;6912:27;:::i;:::-;6904:6;6900:40;7042:6;7030:10;7027:22;7006:18;6994:10;6991:34;6988:62;6985:88;;;7053:18;;:::i;:::-;6985:88;7093:10;7089:2;7082:22;6872:238;6829:281;;:::o;7116:129::-;7150:6;7177:20;;:::i;:::-;7167:30;;7206:33;7234:4;7226:6;7206:33;:::i;:::-;7116:129;;;:::o;7251:311::-;7328:4;7418:18;7410:6;7407:30;7404:56;;;7440:18;;:::i;:::-;7404:56;7490:4;7482:6;7478:17;7470:25;;7550:4;7544;7540:15;7532:23;;7251:311;;;:::o;7585:710::-;7681:5;7706:81;7722:64;7779:6;7722:64;:::i;:::-;7706:81;:::i;:::-;7697:90;;7807:5;7836:6;7829:5;7822:21;7870:4;7863:5;7859:16;7852:23;;7923:4;7915:6;7911:17;7903:6;7899:30;7952:3;7944:6;7941:15;7938:122;;;7971:79;;:::i;:::-;7938:122;8086:6;8069:220;8103:6;8098:3;8095:15;8069:220;;;8178:3;8207:37;8240:3;8228:10;8207:37;:::i;:::-;8202:3;8195:50;8274:4;8269:3;8265:14;8258:21;;8145:144;8129:4;8124:3;8120:14;8113:21;;8069:220;;;8073:21;7687:608;;7585:710;;;;;:::o;8318:370::-;8389:5;8438:3;8431:4;8423:6;8419:17;8415:27;8405:122;;8446:79;;:::i;:::-;8405:122;8563:6;8550:20;8588:94;8678:3;8670:6;8663:4;8655:6;8651:17;8588:94;:::i;:::-;8579:103;;8395:293;8318:370;;;;:::o;8694:117::-;8803:1;8800;8793:12;8817:307;8878:4;8968:18;8960:6;8957:30;8954:56;;;8990:18;;:::i;:::-;8954:56;9028:29;9050:6;9028:29;:::i;:::-;9020:37;;9112:4;9106;9102:15;9094:23;;8817:307;;;:::o;9130:148::-;9228:6;9223:3;9218;9205:30;9269:1;9260:6;9255:3;9251:16;9244:27;9130:148;;;:::o;9284:423::-;9361:5;9386:65;9402:48;9443:6;9402:48;:::i;:::-;9386:65;:::i;:::-;9377:74;;9474:6;9467:5;9460:21;9512:4;9505:5;9501:16;9550:3;9541:6;9536:3;9532:16;9529:25;9526:112;;;9557:79;;:::i;:::-;9526:112;9647:54;9694:6;9689:3;9684;9647:54;:::i;:::-;9367:340;9284:423;;;;;:::o;9726:338::-;9781:5;9830:3;9823:4;9815:6;9811:17;9807:27;9797:122;;9838:79;;:::i;:::-;9797:122;9955:6;9942:20;9980:78;10054:3;10046:6;10039:4;10031:6;10027:17;9980:78;:::i;:::-;9971:87;;9787:277;9726:338;;;;:::o;10070:1509::-;10224:6;10232;10240;10248;10256;10305:3;10293:9;10284:7;10280:23;10276:33;10273:120;;;10312:79;;:::i;:::-;10273:120;10432:1;10457:53;10502:7;10493:6;10482:9;10478:22;10457:53;:::i;:::-;10447:63;;10403:117;10559:2;10585:53;10630:7;10621:6;10610:9;10606:22;10585:53;:::i;:::-;10575:63;;10530:118;10715:2;10704:9;10700:18;10687:32;10746:18;10738:6;10735:30;10732:117;;;10768:79;;:::i;:::-;10732:117;10873:78;10943:7;10934:6;10923:9;10919:22;10873:78;:::i;:::-;10863:88;;10658:303;11028:2;11017:9;11013:18;11000:32;11059:18;11051:6;11048:30;11045:117;;;11081:79;;:::i;:::-;11045:117;11186:78;11256:7;11247:6;11236:9;11232:22;11186:78;:::i;:::-;11176:88;;10971:303;11341:3;11330:9;11326:19;11313:33;11373:18;11365:6;11362:30;11359:117;;;11395:79;;:::i;:::-;11359:117;11500:62;11554:7;11545:6;11534:9;11530:22;11500:62;:::i;:::-;11490:72;;11284:288;10070:1509;;;;;;;;:::o;11585:619::-;11662:6;11670;11678;11727:2;11715:9;11706:7;11702:23;11698:32;11695:119;;;11733:79;;:::i;:::-;11695:119;11853:1;11878:53;11923:7;11914:6;11903:9;11899:22;11878:53;:::i;:::-;11868:63;;11824:117;11980:2;12006:53;12051:7;12042:6;12031:9;12027:22;12006:53;:::i;:::-;11996:63;;11951:118;12108:2;12134:53;12179:7;12170:6;12159:9;12155:22;12134:53;:::i;:::-;12124:63;;12079:118;11585:619;;;;;:::o;12210:311::-;12287:4;12377:18;12369:6;12366:30;12363:56;;;12399:18;;:::i;:::-;12363:56;12449:4;12441:6;12437:17;12429:25;;12509:4;12503;12499:15;12491:23;;12210:311;;;:::o;12544:710::-;12640:5;12665:81;12681:64;12738:6;12681:64;:::i;:::-;12665:81;:::i;:::-;12656:90;;12766:5;12795:6;12788:5;12781:21;12829:4;12822:5;12818:16;12811:23;;12882:4;12874:6;12870:17;12862:6;12858:30;12911:3;12903:6;12900:15;12897:122;;;12930:79;;:::i;:::-;12897:122;13045:6;13028:220;13062:6;13057:3;13054:15;13028:220;;;13137:3;13166:37;13199:3;13187:10;13166:37;:::i;:::-;13161:3;13154:50;13233:4;13228:3;13224:14;13217:21;;13104:144;13088:4;13083:3;13079:14;13072:21;;13028:220;;;13032:21;12646:608;;12544:710;;;;;:::o;13277:370::-;13348:5;13397:3;13390:4;13382:6;13378:17;13374:27;13364:122;;13405:79;;:::i;:::-;13364:122;13522:6;13509:20;13547:94;13637:3;13629:6;13622:4;13614:6;13610:17;13547:94;:::i;:::-;13538:103;;13354:293;13277:370;;;;:::o;13653:894::-;13771:6;13779;13828:2;13816:9;13807:7;13803:23;13799:32;13796:119;;;13834:79;;:::i;:::-;13796:119;13982:1;13971:9;13967:17;13954:31;14012:18;14004:6;14001:30;13998:117;;;14034:79;;:::i;:::-;13998:117;14139:78;14209:7;14200:6;14189:9;14185:22;14139:78;:::i;:::-;14129:88;;13925:302;14294:2;14283:9;14279:18;14266:32;14325:18;14317:6;14314:30;14311:117;;;14347:79;;:::i;:::-;14311:117;14452:78;14522:7;14513:6;14502:9;14498:22;14452:78;:::i;:::-;14442:88;;14237:303;13653:894;;;;;:::o;14553:114::-;14620:6;14654:5;14648:12;14638:22;;14553:114;;;:::o;14673:184::-;14772:11;14806:6;14801:3;14794:19;14846:4;14841:3;14837:14;14822:29;;14673:184;;;;:::o;14863:132::-;14930:4;14953:3;14945:11;;14983:4;14978:3;14974:14;14966:22;;14863:132;;;:::o;15001:108::-;15078:24;15096:5;15078:24;:::i;:::-;15073:3;15066:37;15001:108;;:::o;15115:179::-;15184:10;15205:46;15247:3;15239:6;15205:46;:::i;:::-;15283:4;15278:3;15274:14;15260:28;;15115:179;;;;:::o;15300:113::-;15370:4;15402;15397:3;15393:14;15385:22;;15300:113;;;:::o;15449:732::-;15568:3;15597:54;15645:5;15597:54;:::i;:::-;15667:86;15746:6;15741:3;15667:86;:::i;:::-;15660:93;;15777:56;15827:5;15777:56;:::i;:::-;15856:7;15887:1;15872:284;15897:6;15894:1;15891:13;15872:284;;;15973:6;15967:13;16000:63;16059:3;16044:13;16000:63;:::i;:::-;15993:70;;16086:60;16139:6;16086:60;:::i;:::-;16076:70;;15932:224;15919:1;15916;15912:9;15907:14;;15872:284;;;15876:14;16172:3;16165:10;;15573:608;;;15449:732;;;;:::o;16187:373::-;16330:4;16368:2;16357:9;16353:18;16345:26;;16417:9;16411:4;16407:20;16403:1;16392:9;16388:17;16381:47;16445:108;16548:4;16539:6;16445:108;:::i;:::-;16437:116;;16187:373;;;;:::o;16566:118::-;16653:24;16671:5;16653:24;:::i;:::-;16648:3;16641:37;16566:118;;:::o;16690:222::-;16783:4;16821:2;16810:9;16806:18;16798:26;;16834:71;16902:1;16891:9;16887:17;16878:6;16834:71;:::i;:::-;16690:222;;;;:::o;16918:60::-;16946:3;16967:5;16960:12;;16918:60;;;:::o;16984:142::-;17034:9;17067:53;17085:34;17094:24;17112:5;17094:24;:::i;:::-;17085:34;:::i;:::-;17067:53;:::i;:::-;17054:66;;16984:142;;;:::o;17132:126::-;17182:9;17215:37;17246:5;17215:37;:::i;:::-;17202:50;;17132:126;;;:::o;17264:141::-;17329:9;17362:37;17393:5;17362:37;:::i;:::-;17349:50;;17264:141;;;:::o;17411:161::-;17513:52;17559:5;17513:52;:::i;:::-;17508:3;17501:65;17411:161;;:::o;17578:252::-;17686:4;17724:2;17713:9;17709:18;17701:26;;17737:86;17820:1;17809:9;17805:17;17796:6;17737:86;:::i;:::-;17578:252;;;;:::o;17836:148::-;17908:9;17941:37;17972:5;17941:37;:::i;:::-;17928:50;;17836:148;;;:::o;17990:175::-;18099:59;18152:5;18099:59;:::i;:::-;18094:3;18087:72;17990:175;;:::o;18171:266::-;18286:4;18324:2;18313:9;18309:18;18301:26;;18337:93;18427:1;18416:9;18412:17;18403:6;18337:93;:::i;:::-;18171:266;;;;:::o;18443:180::-;18491:77;18488:1;18481:88;18588:4;18585:1;18578:15;18612:4;18609:1;18602:15;18629:123;18720:1;18713:5;18710:12;18700:46;;18726:18;;:::i;:::-;18700:46;18629:123;:::o;18758:147::-;18813:7;18842:5;18831:16;;18848:51;18893:5;18848:51;:::i;:::-;18758:147;;;:::o;18911:::-;18977:9;19010:42;19046:5;19010:42;:::i;:::-;18997:55;;18911:147;;;:::o;19064:163::-;19167:53;19214:5;19167:53;:::i;:::-;19162:3;19155:66;19064:163;;:::o;19233:254::-;19342:4;19380:2;19369:9;19365:18;19357:26;;19393:87;19477:1;19466:9;19462:17;19453:6;19393:87;:::i;:::-;19233:254;;;;:::o;19493:116::-;19563:21;19578:5;19563:21;:::i;:::-;19556:5;19553:32;19543:60;;19599:1;19596;19589:12;19543:60;19493:116;:::o;19615:133::-;19658:5;19696:6;19683:20;19674:29;;19712:30;19736:5;19712:30;:::i;:::-;19615:133;;;;:::o;19754:468::-;19819:6;19827;19876:2;19864:9;19855:7;19851:23;19847:32;19844:119;;;19882:79;;:::i;:::-;19844:119;20002:1;20027:53;20072:7;20063:6;20052:9;20048:22;20027:53;:::i;:::-;20017:63;;19973:117;20129:2;20155:50;20197:7;20188:6;20177:9;20173:22;20155:50;:::i;:::-;20145:60;;20100:115;19754:468;;;;;:::o;20228:553::-;20405:4;20443:3;20432:9;20428:19;20420:27;;20457:71;20525:1;20514:9;20510:17;20501:6;20457:71;:::i;:::-;20538:72;20606:2;20595:9;20591:18;20582:6;20538:72;:::i;:::-;20620;20688:2;20677:9;20673:18;20664:6;20620:72;:::i;:::-;20702;20770:2;20759:9;20755:18;20746:6;20702:72;:::i;:::-;20228:553;;;;;;;:::o;20787:474::-;20855:6;20863;20912:2;20900:9;20891:7;20887:23;20883:32;20880:119;;;20918:79;;:::i;:::-;20880:119;21038:1;21063:53;21108:7;21099:6;21088:9;21084:22;21063:53;:::i;:::-;21053:63;;21009:117;21165:2;21191:53;21236:7;21227:6;21216:9;21212:22;21191:53;:::i;:::-;21181:63;;21136:118;20787:474;;;;;:::o;21267:1089::-;21371:6;21379;21387;21395;21403;21452:3;21440:9;21431:7;21427:23;21423:33;21420:120;;;21459:79;;:::i;:::-;21420:120;21579:1;21604:53;21649:7;21640:6;21629:9;21625:22;21604:53;:::i;:::-;21594:63;;21550:117;21706:2;21732:53;21777:7;21768:6;21757:9;21753:22;21732:53;:::i;:::-;21722:63;;21677:118;21834:2;21860:53;21905:7;21896:6;21885:9;21881:22;21860:53;:::i;:::-;21850:63;;21805:118;21962:2;21988:53;22033:7;22024:6;22013:9;22009:22;21988:53;:::i;:::-;21978:63;;21933:118;22118:3;22107:9;22103:19;22090:33;22150:18;22142:6;22139:30;22136:117;;;22172:79;;:::i;:::-;22136:117;22277:62;22331:7;22322:6;22311:9;22307:22;22277:62;:::i;:::-;22267:72;;22061:288;21267:1089;;;;;;;;:::o;22362:180::-;22410:77;22407:1;22400:88;22507:4;22504:1;22497:15;22531:4;22528:1;22521:15;22548:320;22592:6;22629:1;22623:4;22619:12;22609:22;;22676:1;22670:4;22666:12;22697:18;22687:81;;22753:4;22745:6;22741:17;22731:27;;22687:81;22815:2;22807:6;22804:14;22784:18;22781:38;22778:84;;22834:18;;:::i;:::-;22778:84;22599:269;22548:320;;;:::o;22874:164::-;23014:16;23010:1;23002:6;22998:14;22991:40;22874:164;:::o;23044:366::-;23186:3;23207:67;23271:2;23266:3;23207:67;:::i;:::-;23200:74;;23283:93;23372:3;23283:93;:::i;:::-;23401:2;23396:3;23392:12;23385:19;;23044:366;;;:::o;23416:419::-;23582:4;23620:2;23609:9;23605:18;23597:26;;23669:9;23663:4;23659:20;23655:1;23644:9;23640:17;23633:47;23697:131;23823:4;23697:131;:::i;:::-;23689:139;;23416:419;;;:::o;23841:180::-;23889:77;23886:1;23879:88;23986:4;23983:1;23976:15;24010:4;24007:1;24000:15;24027:143;24084:5;24115:6;24109:13;24100:22;;24131:33;24158:5;24131:33;:::i;:::-;24027:143;;;;:::o;24176:351::-;24246:6;24295:2;24283:9;24274:7;24270:23;24266:32;24263:119;;;24301:79;;:::i;:::-;24263:119;24421:1;24446:64;24502:7;24493:6;24482:9;24478:22;24446:64;:::i;:::-;24436:74;;24392:128;24176:351;;;;:::o;24533:164::-;24673:16;24669:1;24661:6;24657:14;24650:40;24533:164;:::o;24703:366::-;24845:3;24866:67;24930:2;24925:3;24866:67;:::i;:::-;24859:74;;24942:93;25031:3;24942:93;:::i;:::-;25060:2;25055:3;25051:12;25044:19;;24703:366;;;:::o;25075:419::-;25241:4;25279:2;25268:9;25264:18;25256:26;;25328:9;25322:4;25318:20;25314:1;25303:9;25299:17;25292:47;25356:131;25482:4;25356:131;:::i;:::-;25348:139;;25075:419;;;:::o;25500:442::-;25649:4;25687:2;25676:9;25672:18;25664:26;;25700:71;25768:1;25757:9;25753:17;25744:6;25700:71;:::i;:::-;25781:72;25849:2;25838:9;25834:18;25825:6;25781:72;:::i;:::-;25863;25931:2;25920:9;25916:18;25907:6;25863:72;:::i;:::-;25500:442;;;;;;:::o;25948:332::-;26069:4;26107:2;26096:9;26092:18;26084:26;;26120:71;26188:1;26177:9;26173:17;26164:6;26120:71;:::i;:::-;26201:72;26269:2;26258:9;26254:18;26245:6;26201:72;:::i;:::-;25948:332;;;;;:::o;26286:166::-;26426:18;26422:1;26414:6;26410:14;26403:42;26286:166;:::o;26458:366::-;26600:3;26621:67;26685:2;26680:3;26621:67;:::i;:::-;26614:74;;26697:93;26786:3;26697:93;:::i;:::-;26815:2;26810:3;26806:12;26799:19;;26458:366;;;:::o;26830:419::-;26996:4;27034:2;27023:9;27019:18;27011:26;;27083:9;27077:4;27073:20;27069:1;27058:9;27054:17;27047:47;27111:131;27237:4;27111:131;:::i;:::-;27103:139;;26830:419;;;:::o;27255:165::-;27395:17;27391:1;27383:6;27379:14;27372:41;27255:165;:::o;27426:366::-;27568:3;27589:67;27653:2;27648:3;27589:67;:::i;:::-;27582:74;;27665:93;27754:3;27665:93;:::i;:::-;27783:2;27778:3;27774:12;27767:19;;27426:366;;;:::o;27798:419::-;27964:4;28002:2;27991:9;27987:18;27979:26;;28051:9;28045:4;28041:20;28037:1;28026:9;28022:17;28015:47;28079:131;28205:4;28079:131;:::i;:::-;28071:139;;27798:419;;;:::o;28223:164::-;28363:16;28359:1;28351:6;28347:14;28340:40;28223:164;:::o;28393:366::-;28535:3;28556:67;28620:2;28615:3;28556:67;:::i;:::-;28549:74;;28632:93;28721:3;28632:93;:::i;:::-;28750:2;28745:3;28741:12;28734:19;;28393:366;;;:::o;28765:419::-;28931:4;28969:2;28958:9;28954:18;28946:26;;29018:9;29012:4;29008:20;29004:1;28993:9;28989:17;28982:47;29046:131;29172:4;29046:131;:::i;:::-;29038:139;;28765:419;;;:::o;29190:332::-;29311:4;29349:2;29338:9;29334:18;29326:26;;29362:71;29430:1;29419:9;29415:17;29406:6;29362:71;:::i;:::-;29443:72;29511:2;29500:9;29496:18;29487:6;29443:72;:::i;:::-;29190:332;;;;;:::o;29528:137::-;29582:5;29613:6;29607:13;29598:22;;29629:30;29653:5;29629:30;:::i;:::-;29528:137;;;;:::o;29671:345::-;29738:6;29787:2;29775:9;29766:7;29762:23;29758:32;29755:119;;;29793:79;;:::i;:::-;29755:119;29913:1;29938:61;29991:7;29982:6;29971:9;29967:22;29938:61;:::i;:::-;29928:71;;29884:125;29671:345;;;;:::o;30022:172::-;30162:24;30158:1;30150:6;30146:14;30139:48;30022:172;:::o;30200:366::-;30342:3;30363:67;30427:2;30422:3;30363:67;:::i;:::-;30356:74;;30439:93;30528:3;30439:93;:::i;:::-;30557:2;30552:3;30548:12;30541:19;;30200:366;;;:::o;30572:419::-;30738:4;30776:2;30765:9;30761:18;30753:26;;30825:9;30819:4;30815:20;30811:1;30800:9;30796:17;30789:47;30853:131;30979:4;30853:131;:::i;:::-;30845:139;;30572:419;;;:::o;30997:332::-;31118:4;31156:2;31145:9;31141:18;31133:26;;31169:71;31237:1;31226:9;31222:17;31213:6;31169:71;:::i;:::-;31250:72;31318:2;31307:9;31303:18;31294:6;31250:72;:::i;:::-;30997:332;;;;;:::o;31335:147::-;31436:11;31473:3;31458:18;;31335:147;;;;:::o;31488:114::-;;:::o;31608:398::-;31767:3;31788:83;31869:1;31864:3;31788:83;:::i;:::-;31781:90;;31880:93;31969:3;31880:93;:::i;:::-;31998:1;31993:3;31989:11;31982:18;;31608:398;;;:::o;32012:379::-;32196:3;32218:147;32361:3;32218:147;:::i;:::-;32211:154;;32382:3;32375:10;;32012:379;;;:::o;32397:170::-;32537:22;32533:1;32525:6;32521:14;32514:46;32397:170;:::o;32573:366::-;32715:3;32736:67;32800:2;32795:3;32736:67;:::i;:::-;32729:74;;32812:93;32901:3;32812:93;:::i;:::-;32930:2;32925:3;32921:12;32914:19;;32573:366;;;:::o;32945:419::-;33111:4;33149:2;33138:9;33134:18;33126:26;;33198:9;33192:4;33188:20;33184:1;33173:9;33169:17;33162:47;33226:131;33352:4;33226:131;:::i;:::-;33218:139;;32945:419;;;:::o;33370:161::-;33510:13;33506:1;33498:6;33494:14;33487:37;33370:161;:::o;33537:366::-;33679:3;33700:67;33764:2;33759:3;33700:67;:::i;:::-;33693:74;;33776:93;33865:3;33776:93;:::i;:::-;33894:2;33889:3;33885:12;33878:19;;33537:366;;;:::o;33909:419::-;34075:4;34113:2;34102:9;34098:18;34090:26;;34162:9;34156:4;34152:20;34148:1;34137:9;34133:17;34126:47;34190:131;34316:4;34190:131;:::i;:::-;34182:139;;33909:419;;;:::o;34334:180::-;34382:77;34379:1;34372:88;34479:4;34476:1;34469:15;34503:4;34500:1;34493:15;34520:191;34560:3;34579:20;34597:1;34579:20;:::i;:::-;34574:25;;34613:20;34631:1;34613:20;:::i;:::-;34608:25;;34656:1;34653;34649:9;34642:16;;34677:3;34674:1;34671:10;34668:36;;;34684:18;;:::i;:::-;34668:36;34520:191;;;;:::o;34717:143::-;34774:5;34805:6;34799:13;34790:22;;34821:33;34848:5;34821:33;:::i;:::-;34717:143;;;;:::o;34866:351::-;34936:6;34985:2;34973:9;34964:7;34960:23;34956:32;34953:119;;;34991:79;;:::i;:::-;34953:119;35111:1;35136:64;35192:7;35183:6;35172:9;35168:22;35136:64;:::i;:::-;35126:74;;35082:128;34866:351;;;;:::o;35223:233::-;35262:3;35285:24;35303:5;35285:24;:::i;:::-;35276:33;;35331:66;35324:5;35321:77;35318:103;;35401:18;;:::i;:::-;35318:103;35448:1;35441:5;35437:13;35430:20;;35223:233;;;:::o;35462:86::-;35497:7;35537:4;35530:5;35526:16;35515:27;;35462:86;;;:::o;35554:118::-;35625:22;35641:5;35625:22;:::i;:::-;35618:5;35615:33;35605:61;;35662:1;35659;35652:12;35605:61;35554:118;:::o;35678:139::-;35733:5;35764:6;35758:13;35749:22;;35780:31;35805:5;35780:31;:::i;:::-;35678:139;;;;:::o;35823:347::-;35891:6;35940:2;35928:9;35919:7;35915:23;35911:32;35908:119;;;35946:79;;:::i;:::-;35908:119;36066:1;36091:62;36145:7;36136:6;36125:9;36121:22;36091:62;:::i;:::-;36081:72;;36037:126;35823:347;;;;:::o;36176:102::-;36218:8;36265:5;36262:1;36258:13;36237:34;;36176:102;;;:::o;36284:848::-;36345:5;36352:4;36376:6;36367:15;;36400:5;36391:14;;36414:712;36435:1;36425:8;36422:15;36414:712;;;36530:4;36525:3;36521:14;36515:4;36512:24;36509:50;;;36539:18;;:::i;:::-;36509:50;36589:1;36579:8;36575:16;36572:451;;;37004:4;36997:5;36993:16;36984:25;;36572:451;37054:4;37048;37044:15;37036:23;;37084:32;37107:8;37084:32;:::i;:::-;37072:44;;36414:712;;;36284:848;;;;;;;:::o;37138:1073::-;37192:5;37383:8;37373:40;;37404:1;37395:10;;37406:5;;37373:40;37432:4;37422:36;;37449:1;37440:10;;37451:5;;37422:36;37518:4;37566:1;37561:27;;;;37602:1;37597:191;;;;37511:277;;37561:27;37579:1;37570:10;;37581:5;;;37597:191;37642:3;37632:8;37629:17;37626:43;;;37649:18;;:::i;:::-;37626:43;37698:8;37695:1;37691:16;37682:25;;37733:3;37726:5;37723:14;37720:40;;;37740:18;;:::i;:::-;37720:40;37773:5;;;37511:277;;37897:2;37887:8;37884:16;37878:3;37872:4;37869:13;37865:36;37847:2;37837:8;37834:16;37829:2;37823:4;37820:12;37816:35;37800:111;37797:246;;;37953:8;37947:4;37943:19;37934:28;;37988:3;37981:5;37978:14;37975:40;;;37995:18;;:::i;:::-;37975:40;38028:5;;37797:246;38068:42;38106:3;38096:8;38090:4;38087:1;38068:42;:::i;:::-;38053:57;;;;38142:4;38137:3;38133:14;38126:5;38123:25;38120:51;;;38151:18;;:::i;:::-;38120:51;38200:4;38193:5;38189:16;38180:25;;37138:1073;;;;;;:::o;38217:281::-;38275:5;38299:23;38317:4;38299:23;:::i;:::-;38291:31;;38343:25;38359:8;38343:25;:::i;:::-;38331:37;;38387:104;38424:66;38414:8;38408:4;38387:104;:::i;:::-;38378:113;;38217:281;;;;:::o;38504:410::-;38544:7;38567:20;38585:1;38567:20;:::i;:::-;38562:25;;38601:20;38619:1;38601:20;:::i;:::-;38596:25;;38656:1;38653;38649:9;38678:30;38696:11;38678:30;:::i;:::-;38667:41;;38857:1;38848:7;38844:15;38841:1;38838:22;38818:1;38811:9;38791:83;38768:139;;38887:18;;:::i;:::-;38768:139;38552:362;38504:410;;;;:::o;38920:194::-;38960:4;38980:20;38998:1;38980:20;:::i;:::-;38975:25;;39014:20;39032:1;39014:20;:::i;:::-;39009:25;;39058:1;39055;39051:9;39043:17;;39082:1;39076:4;39073:11;39070:37;;;39087:18;;:::i;:::-;39070:37;38920:194;;;;:::o;39120:180::-;39168:77;39165:1;39158:88;39265:4;39262:1;39255:15;39289:4;39286:1;39279:15;39306:185;39346:1;39363:20;39381:1;39363:20;:::i;:::-;39358:25;;39397:20;39415:1;39397:20;:::i;:::-;39392:25;;39436:1;39426:35;;39441:18;;:::i;:::-;39426:35;39483:1;39480;39476:9;39471:14;;39306:185;;;;:::o;39497:160::-;39637:12;39633:1;39625:6;39621:14;39614:36;39497:160;:::o;39663:366::-;39805:3;39826:67;39890:2;39885:3;39826:67;:::i;:::-;39819:74;;39902:93;39991:3;39902:93;:::i;:::-;40020:2;40015:3;40011:12;40004:19;;39663:366;;;:::o;40035:419::-;40201:4;40239:2;40228:9;40224:18;40216:26;;40288:9;40282:4;40278:20;40274:1;40263:9;40259:17;40252:47;40316:131;40442:4;40316:131;:::i;:::-;40308:139;;40035:419;;;:::o;40460:225::-;40600:34;40596:1;40588:6;40584:14;40577:58;40669:8;40664:2;40656:6;40652:15;40645:33;40460:225;:::o;40691:366::-;40833:3;40854:67;40918:2;40913:3;40854:67;:::i;:::-;40847:74;;40930:93;41019:3;40930:93;:::i;:::-;41048:2;41043:3;41039:12;41032:19;;40691:366;;;:::o;41063:419::-;41229:4;41267:2;41256:9;41252:18;41244:26;;41316:9;41310:4;41306:20;41302:1;41291:9;41287:17;41280:47;41344:131;41470:4;41344:131;:::i;:::-;41336:139;;41063:419;;;:::o;41488:182::-;41628:34;41624:1;41616:6;41612:14;41605:58;41488:182;:::o;41676:366::-;41818:3;41839:67;41903:2;41898:3;41839:67;:::i;:::-;41832:74;;41915:93;42004:3;41915:93;:::i;:::-;42033:2;42028:3;42024:12;42017:19;;41676:366;;;:::o;42048:419::-;42214:4;42252:2;42241:9;42237:18;42229:26;;42301:9;42295:4;42291:20;42287:1;42276:9;42272:17;42265:47;42329:131;42455:4;42329:131;:::i;:::-;42321:139;;42048:419;;;:::o;42473:634::-;42694:4;42732:2;42721:9;42717:18;42709:26;;42781:9;42775:4;42771:20;42767:1;42756:9;42752:17;42745:47;42809:108;42912:4;42903:6;42809:108;:::i;:::-;42801:116;;42964:9;42958:4;42954:20;42949:2;42938:9;42934:18;42927:48;42992:108;43095:4;43086:6;42992:108;:::i;:::-;42984:116;;42473:634;;;;;:::o;43113:98::-;43164:6;43198:5;43192:12;43182:22;;43113:98;;;:::o;43217:168::-;43300:11;43334:6;43329:3;43322:19;43374:4;43369:3;43365:14;43350:29;;43217:168;;;;:::o;43391:373::-;43477:3;43505:38;43537:5;43505:38;:::i;:::-;43559:70;43622:6;43617:3;43559:70;:::i;:::-;43552:77;;43638:65;43696:6;43691:3;43684:4;43677:5;43673:16;43638:65;:::i;:::-;43728:29;43750:6;43728:29;:::i;:::-;43723:3;43719:39;43712:46;;43481:283;43391:373;;;;:::o;43770:751::-;43993:4;44031:3;44020:9;44016:19;44008:27;;44045:71;44113:1;44102:9;44098:17;44089:6;44045:71;:::i;:::-;44126:72;44194:2;44183:9;44179:18;44170:6;44126:72;:::i;:::-;44208;44276:2;44265:9;44261:18;44252:6;44208:72;:::i;:::-;44290;44358:2;44347:9;44343:18;44334:6;44290:72;:::i;:::-;44410:9;44404:4;44400:20;44394:3;44383:9;44379:19;44372:49;44438:76;44509:4;44500:6;44438:76;:::i;:::-;44430:84;;43770:751;;;;;;;;:::o;44527:141::-;44583:5;44614:6;44608:13;44599:22;;44630:32;44656:5;44630:32;:::i;:::-;44527:141;;;;:::o;44674:349::-;44743:6;44792:2;44780:9;44771:7;44767:23;44763:32;44760:119;;;44798:79;;:::i;:::-;44760:119;44918:1;44943:63;44998:7;44989:6;44978:9;44974:22;44943:63;:::i;:::-;44933:73;;44889:127;44674:349;;;;:::o;45029:1053::-;45352:4;45390:3;45379:9;45375:19;45367:27;;45404:71;45472:1;45461:9;45457:17;45448:6;45404:71;:::i;:::-;45485:72;45553:2;45542:9;45538:18;45529:6;45485:72;:::i;:::-;45604:9;45598:4;45594:20;45589:2;45578:9;45574:18;45567:48;45632:108;45735:4;45726:6;45632:108;:::i;:::-;45624:116;;45787:9;45781:4;45777:20;45772:2;45761:9;45757:18;45750:48;45815:108;45918:4;45909:6;45815:108;:::i;:::-;45807:116;;45971:9;45965:4;45961:20;45955:3;45944:9;45940:19;45933:49;45999:76;46070:4;46061:6;45999:76;:::i;:::-;45991:84;;45029:1053;;;;;;;;:::o

ipfs://b24f1afff96faea77b894c754c089b56fabcd2c82fdf0f58f02c046429bbb708