Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IERC165
•    - function supportsInterface(bytes4 int ...
•    - function supportsInterface(bytes4 int ...
• library Strings
•    - function toString(uint256 value)
•    - function toHexString(uint256 value)
•    - function toHexString(uint256 value, u ...
•    - function _msgSender()
•    - function _msgData()
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(
• functionCallWithValue(
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
• functionStaticCall(
•    - function functionStaticCall(
•    - function functionDelegateCall(address ...
• functionDelegateCall(
•    - function functionDelegateCall(
•    - function verifyCallResult(
• interface IERC721Receiver
•    - function onERC721Received(
• interface IERC721 is IERC165
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function safeTransferFrom(
•    - function transferFrom(
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function safeTransferFrom(
• interface IERC721Enumerable is IERC72 ...
•    - function totalSupply()
•    - function tokenOfOwnerByIndex(address ...
•    - function tokenByIndex(uint256 index)
• interface IERC721Metadata is IERC721
•    - function name()
•    - function symbol()
•    - function tokenURI(uint256 tokenId)
•  contract ERC721 is Context, ERC165 ...
•    - function supportsInterface(bytes4 int ...
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function name()
•    - function symbol()
•    - function tokenURI(uint256 tokenId)
•    - function _baseURI()
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function transferFrom(
•    - function safeTransferFrom(
•    - function safeTransferFrom(
•    - function _safeTransfer(
•    - function _exists(uint256 tokenId)
•    - function _isApprovedOrOwner(address s ...
•    - function _safeMint(address to, uint25 ...
•    - function _safeMint(
•    - function _mint(address to, uint256 to ...
•    - function _burn(uint256 tokenId)
•    - function _transfer(
•    - function _approve(address to, uint256 ...
•    - function _setApprovalForAll(
•    - function _checkOnERC721Received(
•    - function _beforeTokenTransfer(
• library SafeERC20
•    - function safeTransfer(
•    - function safeTransferFrom(
•    - function safeApprove(
•    - function safeIncreaseAllowance(
•    - function safeDecreaseAllowance(
•    - function _callOptionalReturn(IERC20 t ...
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
•    - function paused()
•    - function _pause()
•    - function _unpause()
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• library Math
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
•    - function ceilDiv(uint256 a, uint256 b ...
• library EnumerableSet
•    - function _add(Set storage set, bytes3 ...
•    - function _remove(Set storage set, byt ...
•    - function _contains(Set storage set, b ...
•    - function _length(Set storage set)
•    - function _at(Set storage set, uint256 ...
•    - function _values(Set storage set)
•    - function add(Bytes32Set storage set, ...
•    - function remove(Bytes32Set storage se ...
•    - function contains(Bytes32Set storage ...
•    - function length(Bytes32Set storage se ...
•    - function at(Bytes32Set storage set, u ...
•    - function values(Bytes32Set storage se ...
•    - function add(AddressSet storage set, ...
•    - function remove(AddressSet storage se ...
•    - function contains(AddressSet storage ...
•    - function length(AddressSet storage se ...
•    - function at(AddressSet storage set, u ...
•    - function values(AddressSet storage se ...
•    - function add(UintSet storage set, uin ...
•    - function remove(UintSet storage set, ...
•    - function contains(UintSet storage set ...
•    - function length(UintSet storage set)
•    - function at(UintSet storage set, uint ...
•    - function values(UintSet storage set)
• interface liquidForgeStaking
•    - function _liquidKeyForgeBlocks(addres ...
•    - function forgedKeyOwnerAddress(addres ...
•  contract ApeLiquidMembershipForge ... *
•    - function pause()
•    - function unpause()
•    - function setRates(
•    - function setAddresses(
•    - function rewardClaimable(uint256 toke ...
•    - function CalculateEarnedMETL(address ...
•    - function ClaimEarnedMETL(uint256[] ca ...
•    - function ForgeNFT(uint256[] calldata ...
•    - function WithdrawNFT(uint256[] callda ...
•    - function WithdrawEarnedMETL()
•    - function onERC721Received(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-11-02
*/

// SPDX-License-Identifier: MIT
/*
   .____    .__             .__    .___   ___________
   |    |   |__| ________ __|__| __| _/   \_   _____/__________  ____   ____
   |    |   |  |/ ____/  |  \  |/ __ |     |    __)/  _ \_  __ \/ ___\_/ __ \
   |    |___|  < <_|  |  |  /  / /_/ |     |     \(  <_> )  | \/ /_/  >  ___/
   |_______ \__|\__   |____/|__\____ |     \___  / \____/|__|  \___  / \___  >
           \/      |__|             \/         \/             /_____/      \/

    * Liquid Forge Contract for ApeLiquid.io | November 2022
    *
    * ApeLiquid Membership Forge: 10 METL/month for 8 Months
    * Plus Azuki Royalties (paid in METL) across all Memberships
*/

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

pragma solidity ^0.8.0;

/**
 * @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);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId)
        public
        view
        virtual
        override
        returns (bool)
    {
        return interfaceId == type(IERC165).interfaceId;
    }
}

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length)
        internal
        pure
        returns (string memory)
    {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

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

pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

pragma solidity ^0.8.0;

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

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index)
        external
        view
        returns (uint256 tokenId);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

pragma solidity ^0.8.0;

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

pragma solidity ^0.8.0;

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

    // Mapping from token ID to approved address
    mapping(uint256 => address) private _tokenApprovals;

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

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

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

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner)
        public
        view
        virtual
        override
        returns (uint256)
    {
        require(
            owner != address(0),
            "ERC721: balance query for the zero address"
        );
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId)
        public
        view
        virtual
        override
        returns (address)
    {
        address owner = _owners[tokenId];
        require(
            owner != address(0),
            "ERC721: owner query for nonexistent token"
        );
        return owner;
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId)
        public
        view
        virtual
        override
        returns (string memory)
    {
        require(
            _exists(tokenId),
            "ERC721Metadata: URI query for nonexistent token"
        );

        string memory baseURI = _baseURI();
        return
            bytes(baseURI).length > 0
                ? string(abi.encodePacked(baseURI, tokenId.toString()))
                : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overriden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not owner nor approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId)
        public
        view
        virtual
        override
        returns (address)
    {
        require(
            _exists(tokenId),
            "ERC721: approved query for nonexistent token"
        );

        return _tokenApprovals[tokenId];
    }

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

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

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(
            _isApprovedOrOwner(_msgSender(), tokenId),
            "ERC721: transfer caller is not owner nor approved"
        );

        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        require(
            _isApprovedOrOwner(_msgSender(), tokenId),
            "ERC721: transfer caller is not owner nor approved"
        );
        _safeTransfer(from, to, tokenId, _data);
    }

    /**
     * @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.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(
            _checkOnERC721Received(from, to, tokenId, _data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _owners[tokenId] != address(0);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId)
        internal
        view
        virtual
        returns (bool)
    {
        require(
            _exists(tokenId),
            "ERC721: operator query for nonexistent token"
        );
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner ||
            getApproved(tokenId) == spender ||
            isApprovedForAll(owner, spender));
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _mint(to, tokenId);
        require(
            _checkOnERC721Received(address(0), to, tokenId, _data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId);

        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(address(0), to, tokenId);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

        _beforeTokenTransfer(owner, address(0), tokenId);

        // Clear approvals
        _approve(address(0), tokenId);

        _balances[owner] -= 1;
        delete _owners[tokenId];

        emit Transfer(owner, address(0), tokenId);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {
        require(
            ERC721.ownerOf(tokenId) == from,
            "ERC721: transfer of token that is not own"
        );
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId);

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits a {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits a {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        if (to.isContract()) {
            try
                IERC721Receiver(to).onERC721Received(
                    _msgSender(),
                    from,
                    tokenId,
                    _data
                )
            returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert(
                        "ERC721: transfer to non ERC721Receiver implementer"
                    );
                } else {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}
}

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

    bool private _paused;

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(
            newOwner != address(0),
            "Ownable: new owner is the zero address"
        );
        _transferOwnership(newOwner);
    }

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

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @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) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a / b + (a % b == 0 ? 0 : 1);
    }
}

pragma solidity ^0.8.0;

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

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

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

        _;

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

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastvalue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastvalue;
                // Update the index for the moved value
                set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value)
        private
        view
        returns (bool)
    {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index)
        private
        view
        returns (bytes32)
    {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value)
        internal
        returns (bool)
    {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value)
        internal
        returns (bool)
    {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value)
        internal
        view
        returns (bool)
    {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index)
        internal
        view
        returns (bytes32)
    {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set)
        internal
        view
        returns (bytes32[] memory)
    {
        return _values(set._inner);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value)
        internal
        returns (bool)
    {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value)
        internal
        returns (bool)
    {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value)
        internal
        view
        returns (bool)
    {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index)
        internal
        view
        returns (address)
    {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set)
        internal
        view
        returns (address[] memory)
    {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value)
        internal
        returns (bool)
    {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value)
        internal
        view
        returns (bool)
    {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index)
        internal
        view
        returns (uint256)
    {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set)
        internal
        view
        returns (uint256[] memory)
    {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        assembly {
            result := store
        }

        return result;
    }
}

pragma solidity ^0.8.0;

interface liquidForgeStaking {
    // get the forgeblocks for the forged liquid key
    function _liquidKeyForgeBlocks(address) external view returns (uint256);

    // Retrieve the Token IDs of the Forged Liquid Key address
    function forgedKeyOwnerAddress(address account)
        external
        view
        returns (uint256[] memory);
}

contract ApeLiquidMembershipForge is Ownable, ReentrancyGuard, Pausable {
    using EnumerableSet for EnumerableSet.UintSet;

    mapping(uint256 => uint256) public nftForgeBlocks;
    mapping(address => EnumerableSet.UintSet) private nftForges; // private
    mapping(uint256 => address) public _nftTokenForges;

    // NFT Collection, Forge, and METL token addresses
    address public nftAddress = 0x61028F622CB6618cAC3DeB9ef0f0D5B9c6369C72; // ApeLiquid Membership
    address public forgeAddress = 0x346e31ddE260c6BEEA84186ad99878C1D8C7D90F; // Liquid Key Forge
    address public metlTokenAddress = 0xFcbE615dEf610E806BB64427574A2c5c1fB55510; // METL Token

    // how many blocks before a claim (30 days) and when do we expire?
    uint256 public expiration = 1000000000;
    uint256 public minBlockToClaim = 180204;

    // rate governs how often you receive your token
    uint256 public nftRate = 64676699740294; // nft earning rate

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

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

    // Set this to a expiration block to disable the ability to continue accruing tokens past that block number.
    // which is calculated as current block plus the parameters
    //
    // Set a multiplier for how many tokens to earn each time a block passes
    // and the min number of blocks needed to pass to claim rewards
    function setRates(
        uint256 _nftRate,
        uint256 _minBlockToClaim,
        uint256 _expiration
    ) public onlyOwner {
        nftRate = _nftRate;
        minBlockToClaim = _minBlockToClaim;
        expiration = block.number + _expiration;
    }

    // Set addresses
    function setAddresses(
        address _nftAddress, 
        address _forgeAddress, 
        address _metlTokenAddress
    ) public onlyOwner {
        nftAddress = _nftAddress;
        forgeAddress = _forgeAddress;
        metlTokenAddress = _metlTokenAddress;
    }

    // Reward Claimable information
    function rewardClaimable(uint256 tokenId) public view returns (bool) {
        uint256 blockCur = Math.min(block.number, expiration);
        if (nftForgeBlocks[tokenId] > 0) {
            return (blockCur - nftForgeBlocks[tokenId] > minBlockToClaim);
        }
        return false;
    }

    // reward amount by address/tokenIds[]
    function CalculateEarnedMETL(address account, uint256 tokenId)
        public
        view
        returns (uint256)
    {
        require(
            Math.min(block.number, expiration) > nftForgeBlocks[tokenId],
            "Invalid blocks"
        );
        return
            nftRate *
            (nftForges[msg.sender].contains(tokenId) ? 1 : 0) *
            (Math.min(block.number, expiration) -
                Math.max(
                    liquidForgeStaking(forgeAddress)._liquidKeyForgeBlocks(
                        account
                    ),
                    nftForgeBlocks[tokenId]
                ));
    }

    // claim rewards (earned METL)
    function ClaimEarnedMETL(uint256[] calldata tokenIds) public whenNotPaused {
        uint256 reward;
        uint256 blockCur = Math.min(block.number, expiration);

        require(
            liquidForgeStaking(forgeAddress)
                .forgedKeyOwnerAddress(msg.sender)
                .length > 0,
            "No Liquid Key Forged"
        );

        for (uint256 i; i < tokenIds.length; i++) {
            require(
                nftForges[msg.sender].contains(tokenIds[i]),
                "Staking: token not forged"
            );
            require(blockCur - nftForgeBlocks[tokenIds[i]] > minBlockToClaim);
        }

        for (uint256 i; i < tokenIds.length; i++) {
            reward += CalculateEarnedMETL(msg.sender, tokenIds[i]);
            nftForgeBlocks[tokenIds[i]] = blockCur;
        }

        if (reward > 0) {
            IERC20(metlTokenAddress).transfer(msg.sender, reward);
        }
    }

    // Forge NFT
    function ForgeNFT(uint256[] calldata tokenIds)
        external
        whenNotPaused
    {
        uint256 blockCur = block.number;
        require(msg.sender != nftAddress, "Invalid NFT contract address");

        for (uint256 i; i < tokenIds.length; i++) {
            IERC721(nftAddress).safeTransferFrom(
                msg.sender,
                address(this),
                tokenIds[i],
                "Transfer from Member to Forge"
            );
            nftForges[msg.sender].add(tokenIds[i]);
            nftForgeBlocks[tokenIds[i]] = blockCur;
            // write the entry for the ETH address
            _nftTokenForges[tokenIds[i]] = msg.sender;
        }
    }

    // withdrawal function
    function WithdrawNFT(uint256[] calldata tokenIds)
        external
        whenNotPaused
        nonReentrant
    {
        for (uint256 i; i < tokenIds.length; i++) {
            require(
                nftForges[msg.sender].contains(tokenIds[i]),
                "Staking: token not forged"
            );

            nftForges[msg.sender].remove(tokenIds[i]);
            _nftTokenForges[tokenIds[i]] = 0x0000000000000000000000000000000000000000;

            IERC721(nftAddress).safeTransferFrom(
                address(this),
                msg.sender,
                tokenIds[i],
                "Not withdrawn: Transfer failed"
            );
        }
    }

    // withdraw earned METL
    function WithdrawEarnedMETL() external onlyOwner {
        uint256 tokenSupply = IERC20(metlTokenAddress).balanceOf(address(this));
        IERC20(metlTokenAddress).transfer(msg.sender, tokenSupply);
    }
    
    // ERC721 token receiver for transferred NFT to Forge
    function onERC721Received(
        address,
        address,
        uint256,
        bytes calldata
    ) external pure  returns (bytes4) {
        return IERC721Receiver.onERC721Received.selector;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"CalculateEarnedMETL","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"ClaimEarnedMETL","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"ForgeNFT","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"WithdrawEarnedMETL","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"WithdrawNFT","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"_nftTokenForges","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"expiration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"forgeAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"metlTokenAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minBlockToClaim","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nftAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"nftForgeBlocks","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nftRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"rewardClaimable","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_nftAddress","type":"address"},{"internalType":"address","name":"_forgeAddress","type":"address"},{"internalType":"address","name":"_metlTokenAddress","type":"address"}],"name":"setAddresses","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_nftRate","type":"uint256"},{"internalType":"uint256","name":"_minBlockToClaim","type":"uint256"},{"internalType":"uint256","name":"_expiration","type":"uint256"}],"name":"setRates","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

64688:6044:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66747:295;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70518:211;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65587:39;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65269:76;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69511:691;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;66427:275;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;65724:65;;;:::i;:::-;;65440:38;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64821:49;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65069:70;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43949:86;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;68769:706;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;46757:103;;;:::i;:::-;;65655:61;;;:::i;:::-;;67788:955;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;65170:72;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46106:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64954:50;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70239:208;;;:::i;:::-;;65485:39;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67094:650;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66131:266;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;47015:238;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;66747:295;66810:4;66827:16;66846:34;66855:12;66869:10;;66846:8;:34::i;:::-;66827:53;;66921:1;66895:14;:23;66910:7;66895:23;;;;;;;;;;;;:27;66891:121;;;66984:15;;66958:14;:23;66973:7;66958:23;;;;;;;;;;;;66947:8;:34;;;;:::i;:::-;:52;66939:61;;;;;66891:121;67029:5;67022:12;;;66747:295;;;;:::o;70518:211::-;70654:6;70680:41;;;70673:48;;70518:211;;;;;;;:::o;65587:39::-;;;;:::o;65269:76::-;;;;;;;;;;;;;:::o;69511:691::-;44275:8;:6;:8::i;:::-;44274:9;44266:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;50455:1:::1;51051:7;;:19;;51043:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;50455:1;51184:7;:18;;;;69645:9:::2;69640:555;69660:8;;:15;;69656:1;:19;69640:555;;;69723:43;69754:8;;69763:1;69754:11;;;;;;;:::i;:::-;;;;;;;;69723:9;:21;69733:10;69723:21;;;;;;;;;;;;;;;:30;;:43;;;;:::i;:::-;69697:130;;;;;;;;;;;;:::i;:::-;;;;;;;;;69844:41;69873:8;;69882:1;69873:11;;;;;;;:::i;:::-;;;;;;;;69844:9;:21;69854:10;69844:21;;;;;;;;;;;;;;;:28;;:41;;;;:::i;:::-;;69931:42;69900:15;:28;69916:8;;69925:1;69916:11;;;;;;;:::i;:::-;;;;;;;;69900:28;;;;;;;;;;;;:73;;;;;;;;;;;;;;;;;;69998:10;;;;;;;;;;;69990:36;;;70053:4;70077:10;70106:8;;70115:1;70106:11;;;;;;;:::i;:::-;;;;;;;;69990:193;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;69677:3;;;;;:::i;:::-;;;;69640:555;;;;50411:1:::1;51363:7:::0;:22:::1;;;;69511:691:::0;;:::o;66427:275::-;46337:12;:10;:12::i;:::-;46326:23;;:7;:5;:7::i;:::-;:23;;;46318:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;66597:11:::1;66584:10;;:24;;;;;;;;;;;;;;;;;;66634:13;66619:12;;:28;;;;;;;;;;;;;;;;;;66677:17;66658:16;;:36;;;;;;;;;;;;;;;;;;66427:275:::0;;;:::o;65724:65::-;46337:12;:10;:12::i;:::-;46326:23;;:7;:5;:7::i;:::-;:23;;;46318:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;65771:10:::1;:8;:10::i;:::-;65724:65::o:0;65440:38::-;;;;:::o;64821:49::-;;;;;;;;;;;;;;;;;:::o;65069:70::-;;;;;;;;;;;;;:::o;43949:86::-;43996:4;44020:7;;;;;;;;;;;44013:14;;43949:86;:::o;68769:706::-;44275:8;:6;:8::i;:::-;44274:9;44266:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;68873:16:::1;68892:12;68873:31;;68937:10;;;;;;;;;;;68923:24;;:10;:24;;;;68915:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;68998:9;68993:475;69013:8;;:15;;69009:1;:19;68993:475;;;69058:10;;;;;;;;;;;69050:36;;;69105:10;69142:4;69166:8;;69175:1;69166:11;;;;;;;:::i;:::-;;;;;;;;69050:192;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;69257:38;69283:8;;69292:1;69283:11;;;;;;;:::i;:::-;;;;;;;;69257:9;:21;69267:10;69257:21;;;;;;;;;;;;;;;:25;;:38;;;;:::i;:::-;;69340:8;69310:14;:27;69325:8;;69334:1;69325:11;;;;;;;:::i;:::-;;;;;;;;69310:27;;;;;;;;;;;:38;;;;69446:10;69415:15;:28;69431:8;;69440:1;69431:11;;;;;;;:::i;:::-;;;;;;;;69415:28;;;;;;;;;;;;:41;;;;;;;;;;;;;;;;;;69030:3;;;;;:::i;:::-;;;;68993:475;;;;68862:613;68769:706:::0;;:::o;46757:103::-;46337:12;:10;:12::i;:::-;46326:23;;:7;:5;:7::i;:::-;:23;;;46318:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;46822:30:::1;46849:1;46822:18;:30::i;:::-;46757:103::o:0;65655:61::-;46337:12;:10;:12::i;:::-;46326:23;;:7;:5;:7::i;:::-;:23;;;46318:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;65700:8:::1;:6;:8::i;:::-;65655:61::o:0;67788:955::-;44275:8;:6;:8::i;:::-;44274:9;44266:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;67874:14:::1;67899:16:::0;67918:34:::1;67927:12;67941:10;;67918:8;:34::i;:::-;67899:53;;68099:1;68006:12;;;;;;;;;;;67987:72;;;68060:10;67987:84;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:109;:113;67965:183;;;;;;;;;;;;:::i;:::-;;;;;;;;;68166:9;68161:279;68181:8;;:15;;68177:1;:19;68161:279;;;68244:43;68275:8;;68284:1;68275:11;;;;;;;:::i;:::-;;;;;;;;68244:9;:21;68254:10;68244:21;;;;;;;;;;;;;;;:30;;:43;;;;:::i;:::-;68218:130;;;;;;;;;;;;:::i;:::-;;;;;;;;;68412:15;;68382:14;:27;68397:8;;68406:1;68397:11;;;;;;;:::i;:::-;;;;;;;;68382:27;;;;;;;;;;;;68371:8;:38;;;;:::i;:::-;:56;68363:65;;;::::0;::::1;;68198:3;;;;;:::i;:::-;;;;68161:279;;;;68457:9;68452:176;68472:8;;:15;;68468:1;:19;68452:176;;;68519:44;68539:10;68551:8;;68560:1;68551:11;;;;;;;:::i;:::-;;;;;;;;68519:19;:44::i;:::-;68509:54;;;;;:::i;:::-;;;68608:8;68578:14;:27;68593:8;;68602:1;68593:11;;;;;;;:::i;:::-;;;;;;;;68578:27;;;;;;;;;;;:38;;;;68489:3;;;;;:::i;:::-;;;;68452:176;;;;68653:1;68644:6;:10;68640:96;;;68678:16;;;;;;;;;;;68671:33;;;68705:10;68717:6;68671:53;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;68640:96;67863:880;;67788:955:::0;;:::o;65170:72::-;;;;;;;;;;;;;:::o;46106:87::-;46152:7;46179:6;;;;;;;;;;;46172:13;;46106:87;:::o;64954:50::-;;;;;;;;;;;;;;;;;;;;;;:::o;70239:208::-;46337:12;:10;:12::i;:::-;46326:23;;:7;:5;:7::i;:::-;:23;;;46318:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;70299:19:::1;70328:16;;;;;;;;;;;70321:34;;;70364:4;70321:49;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;70299:71;;70388:16;;;;;;;;;;;70381:33;;;70415:10;70427:11;70381:58;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;70288:159;70239:208::o:0;65485:39::-;;;;:::o;67094:650::-;67205:7;67289:14;:23;67304:7;67289:23;;;;;;;;;;;;67252:34;67261:12;67275:10;;67252:8;:34::i;:::-;:60;67230:124;;;;;;;;;;;;:::i;:::-;;;;;;;;;67528:207;67578:12;;;;;;;;;;;67559:54;;;67640:7;67559:111;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;67693:14;:23;67708:7;67693:23;;;;;;;;;;;;67528:8;:207::i;:::-;67474:34;67483:12;67497:10;;67474:8;:34::i;:::-;:261;;;;:::i;:::-;67409:39;67440:7;67409:9;:21;67419:10;67409:21;;;;;;;;;;;;;;;:30;;:39;;;;:::i;:::-;:47;;67455:1;67409:47;;;67451:1;67409:47;67385:72;;:7;;:72;;;;:::i;:::-;:351;;;;:::i;:::-;67365:371;;67094:650;;;;:::o;66131:266::-;46337:12;:10;:12::i;:::-;46326:23;;:7;:5;:7::i;:::-;:23;;;46318:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;66286:8:::1;66276:7;:18;;;;66323:16;66305:15;:34;;;;66378:11;66363:12;:26;;;;:::i;:::-;66350:10;:39;;;;66131:266:::0;;;:::o;47015:238::-;46337:12;:10;:12::i;:::-;46326:23;;:7;:5;:7::i;:::-;:23;;;46318:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;47138:1:::1;47118:22;;:8;:22;;;;47096:110;;;;;;;;;;;;:::i;:::-;;;;;;;;;47217:28;47236:8;47217:18;:28::i;:::-;47015:238:::0;:::o;47985:106::-;48043:7;48074:1;48070;:5;:13;;48082:1;48070:13;;;48078:1;48070:13;48063:20;;47985:106;;;;:::o;62551:178::-;62655:4;62684:37;62694:3;:10;;62714:5;62706:14;;62684:9;:37::i;:::-;62677:44;;62551:178;;;;:::o;62305:160::-;62393:4;62422:35;62430:3;:10;;62450:5;62442:14;;62422:7;:35::i;:::-;62415:42;;62305:160;;;;:::o;5019:98::-;5072:7;5099:10;5092:17;;5019:98;:::o;45008:120::-;44552:8;:6;:8::i;:::-;44544:41;;;;;;;;;;;;:::i;:::-;;;;;;;;;45077:5:::1;45067:7;;:15;;;;;;;;;;;;;;;;;;45098:22;45107:12;:10;:12::i;:::-;45098:22;;;;;;:::i;:::-;;;;;;;;45008:120::o:0;61998:131::-;62065:4;62089:32;62094:3;:10;;62114:5;62106:14;;62089:4;:32::i;:::-;62082:39;;61998:131;;;;:::o;47413:191::-;47487:16;47506:6;;;;;;;;;;;47487:25;;47532:8;47523:6;;:17;;;;;;;;;;;;;;;;;;47587:8;47556:40;;47577:8;47556:40;;;;;;;;;;;;47476:128;47413:191;:::o;44749:118::-;44275:8;:6;:8::i;:::-;44274:9;44266:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;44819:4:::1;44809:7;;:14;;;;;;;;;;;;;;;;;;44839:20;44846:12;:10;:12::i;:::-;44839:20;;;;;;:::i;:::-;;;;;;;;44749:118::o:0;47802:107::-;47860:7;47892:1;47887;:6;;:14;;47900:1;47887:14;;;47896:1;47887:14;47880:21;;47802:107;;;;:::o;55143:161::-;55243:4;55295:1;55272:3;:12;;:19;55285:5;55272:19;;;;;;;;;;;;:24;;55265:31;;55143:161;;;;:::o;53637:1420::-;53703:4;53821:18;53842:3;:12;;:19;53855:5;53842:19;;;;;;;;;;;;53821:40;;53892:1;53878:10;:15;53874:1176;;54253:21;54290:1;54277:10;:14;;;;:::i;:::-;54253:38;;54306:17;54347:1;54326:3;:11;;:18;;;;:22;;;;:::i;:::-;54306:42;;54382:13;54369:9;:26;54365:405;;54416:17;54436:3;:11;;54448:9;54436:22;;;;;;;;:::i;:::-;;;;;;;;;;54416:42;;54590:9;54561:3;:11;;54573:13;54561:26;;;;;;;;:::i;:::-;;;;;;;;;:38;;;;54701:10;54675:3;:12;;:23;54688:9;54675:23;;;;;;;;;;;:36;;;;54397:373;54365:405;54851:3;:11;;:17;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;54946:3;:12;;:19;54959:5;54946:19;;;;;;;;;;;54939:26;;;54989:4;54982:11;;;;;;;53874:1176;55033:5;55026:12;;;53637:1420;;;;;:::o;53047:414::-;53110:4;53132:21;53142:3;53147:5;53132:9;:21::i;:::-;53127:327;;53170:3;:11;;53187:5;53170:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53353:3;:11;;:18;;;;53331:3;:12;;:19;53344:5;53331:19;;;;;;;;;;;:40;;;;53393:4;53386:11;;;;53127:327;53437:5;53430:12;;53047:414;;;;;:::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:77;371:7;400:5;389:16;;334:77;;;:::o;417:122::-;490:24;508:5;490:24;:::i;:::-;483:5;480:35;470:63;;529:1;526;519:12;470:63;417:122;:::o;545:139::-;591:5;629:6;616:20;607:29;;645:33;672:5;645:33;:::i;:::-;545:139;;;;:::o;690:329::-;749:6;798:2;786:9;777:7;773:23;769:32;766:119;;;804:79;;:::i;:::-;766:119;924:1;949:53;994:7;985:6;974:9;970:22;949:53;:::i;:::-;939:63;;895:117;690:329;;;;:::o;1025:90::-;1059:7;1102:5;1095:13;1088:21;1077:32;;1025:90;;;:::o;1121:109::-;1202:21;1217:5;1202:21;:::i;:::-;1197:3;1190:34;1121:109;;:::o;1236:210::-;1323:4;1361:2;1350:9;1346:18;1338:26;;1374:65;1436:1;1425:9;1421:17;1412:6;1374:65;:::i;:::-;1236:210;;;;:::o;1452:126::-;1489:7;1529:42;1522:5;1518:54;1507:65;;1452:126;;;:::o;1584:96::-;1621:7;1650:24;1668:5;1650:24;:::i;:::-;1639:35;;1584:96;;;:::o;1686:122::-;1759:24;1777:5;1759:24;:::i;:::-;1752:5;1749:35;1739:63;;1798:1;1795;1788:12;1739:63;1686:122;:::o;1814:139::-;1860:5;1898:6;1885:20;1876:29;;1914:33;1941:5;1914:33;:::i;:::-;1814:139;;;;:::o;1959:117::-;2068:1;2065;2058:12;2082:117;2191:1;2188;2181:12;2205:117;2314:1;2311;2304:12;2341:552;2398:8;2408:6;2458:3;2451:4;2443:6;2439:17;2435:27;2425:122;;2466:79;;:::i;:::-;2425:122;2579:6;2566:20;2556:30;;2609:18;2601:6;2598:30;2595:117;;;2631:79;;:::i;:::-;2595:117;2745:4;2737:6;2733:17;2721:29;;2799:3;2791:4;2783:6;2779:17;2769:8;2765:32;2762:41;2759:128;;;2806:79;;:::i;:::-;2759:128;2341:552;;;;;:::o;2899:963::-;2996:6;3004;3012;3020;3028;3077:3;3065:9;3056:7;3052:23;3048:33;3045:120;;;3084:79;;:::i;:::-;3045:120;3204:1;3229:53;3274:7;3265:6;3254:9;3250:22;3229:53;:::i;:::-;3219:63;;3175:117;3331:2;3357:53;3402:7;3393:6;3382:9;3378:22;3357:53;:::i;:::-;3347:63;;3302:118;3459:2;3485:53;3530:7;3521:6;3510:9;3506:22;3485:53;:::i;:::-;3475:63;;3430:118;3615:2;3604:9;3600:18;3587:32;3646:18;3638:6;3635:30;3632:117;;;3668:79;;:::i;:::-;3632:117;3781:64;3837:7;3828:6;3817:9;3813:22;3781:64;:::i;:::-;3763:82;;;;3558:297;2899:963;;;;;;;;:::o;3868:149::-;3904:7;3944:66;3937:5;3933:78;3922:89;;3868:149;;;:::o;4023:115::-;4108:23;4125:5;4108:23;:::i;:::-;4103:3;4096:36;4023:115;;:::o;4144:218::-;4235:4;4273:2;4262:9;4258:18;4250:26;;4286:69;4352:1;4341:9;4337:17;4328:6;4286:69;:::i;:::-;4144:218;;;;:::o;4368:118::-;4455:24;4473:5;4455:24;:::i;:::-;4450:3;4443:37;4368:118;;:::o;4492:222::-;4585:4;4623:2;4612:9;4608:18;4600:26;;4636:71;4704:1;4693:9;4689:17;4680:6;4636:71;:::i;:::-;4492:222;;;;:::o;4720:118::-;4807:24;4825:5;4807:24;:::i;:::-;4802:3;4795:37;4720:118;;:::o;4844:222::-;4937:4;4975:2;4964:9;4960:18;4952:26;;4988:71;5056:1;5045:9;5041:17;5032:6;4988:71;:::i;:::-;4844:222;;;;:::o;5089:568::-;5162:8;5172:6;5222:3;5215:4;5207:6;5203:17;5199:27;5189:122;;5230:79;;:::i;:::-;5189:122;5343:6;5330:20;5320:30;;5373:18;5365:6;5362:30;5359:117;;;5395:79;;:::i;:::-;5359:117;5509:4;5501:6;5497:17;5485:29;;5563:3;5555:4;5547:6;5543:17;5533:8;5529:32;5526:41;5523:128;;;5570:79;;:::i;:::-;5523:128;5089:568;;;;;:::o;5663:559::-;5749:6;5757;5806:2;5794:9;5785:7;5781:23;5777:32;5774:119;;;5812:79;;:::i;:::-;5774:119;5960:1;5949:9;5945:17;5932:31;5990:18;5982:6;5979:30;5976:117;;;6012:79;;:::i;:::-;5976:117;6125:80;6197:7;6188:6;6177:9;6173:22;6125:80;:::i;:::-;6107:98;;;;5903:312;5663:559;;;;;:::o;6228:619::-;6305:6;6313;6321;6370:2;6358:9;6349:7;6345:23;6341:32;6338:119;;;6376:79;;:::i;:::-;6338:119;6496:1;6521:53;6566:7;6557:6;6546:9;6542:22;6521:53;:::i;:::-;6511:63;;6467:117;6623:2;6649:53;6694:7;6685:6;6674:9;6670:22;6649:53;:::i;:::-;6639:63;;6594:118;6751:2;6777:53;6822:7;6813:6;6802:9;6798:22;6777:53;:::i;:::-;6767:63;;6722:118;6228:619;;;;;:::o;6853:474::-;6921:6;6929;6978:2;6966:9;6957:7;6953:23;6949:32;6946:119;;;6984:79;;:::i;:::-;6946:119;7104:1;7129:53;7174:7;7165:6;7154:9;7150:22;7129:53;:::i;:::-;7119:63;;7075:117;7231:2;7257:53;7302:7;7293:6;7282:9;7278:22;7257:53;:::i;:::-;7247:63;;7202:118;6853:474;;;;;:::o;7333:619::-;7410:6;7418;7426;7475:2;7463:9;7454:7;7450:23;7446:32;7443:119;;;7481:79;;:::i;:::-;7443:119;7601:1;7626:53;7671:7;7662:6;7651:9;7647:22;7626:53;:::i;:::-;7616:63;;7572:117;7728:2;7754:53;7799:7;7790:6;7779:9;7775:22;7754:53;:::i;:::-;7744:63;;7699:118;7856:2;7882:53;7927:7;7918:6;7907:9;7903:22;7882:53;:::i;:::-;7872:63;;7827:118;7333:619;;;;;:::o;7958:329::-;8017:6;8066:2;8054:9;8045:7;8041:23;8037:32;8034:119;;;8072:79;;:::i;:::-;8034:119;8192:1;8217:53;8262:7;8253:6;8242:9;8238:22;8217:53;:::i;:::-;8207:63;;8163:117;7958:329;;;;:::o;8293:180::-;8341:77;8338:1;8331:88;8438:4;8435:1;8428:15;8462:4;8459:1;8452:15;8479:191;8519:4;8539:20;8557:1;8539:20;:::i;:::-;8534:25;;8573:20;8591:1;8573:20;:::i;:::-;8568:25;;8612:1;8609;8606:8;8603:34;;;8617:18;;:::i;:::-;8603:34;8662:1;8659;8655:9;8647:17;;8479:191;;;;:::o;8676:169::-;8760:11;8794:6;8789:3;8782:19;8834:4;8829:3;8825:14;8810:29;;8676:169;;;;:::o;8851:166::-;8991:18;8987:1;8979:6;8975:14;8968:42;8851:166;:::o;9023:366::-;9165:3;9186:67;9250:2;9245:3;9186:67;:::i;:::-;9179:74;;9262:93;9351:3;9262:93;:::i;:::-;9380:2;9375:3;9371:12;9364:19;;9023:366;;;:::o;9395:419::-;9561:4;9599:2;9588:9;9584:18;9576:26;;9648:9;9642:4;9638:20;9634:1;9623:9;9619:17;9612:47;9676:131;9802:4;9676:131;:::i;:::-;9668:139;;9395:419;;;:::o;9820:181::-;9960:33;9956:1;9948:6;9944:14;9937:57;9820:181;:::o;10007:366::-;10149:3;10170:67;10234:2;10229:3;10170:67;:::i;:::-;10163:74;;10246:93;10335:3;10246:93;:::i;:::-;10364:2;10359:3;10355:12;10348:19;;10007:366;;;:::o;10379:419::-;10545:4;10583:2;10572:9;10568:18;10560:26;;10632:9;10626:4;10622:20;10618:1;10607:9;10603:17;10596:47;10660:131;10786:4;10660:131;:::i;:::-;10652:139;;10379:419;;;:::o;10804:180::-;10852:77;10849:1;10842:88;10949:4;10946:1;10939:15;10973:4;10970:1;10963:15;10990:175;11130:27;11126:1;11118:6;11114:14;11107:51;10990:175;:::o;11171:366::-;11313:3;11334:67;11398:2;11393:3;11334:67;:::i;:::-;11327:74;;11410:93;11499:3;11410:93;:::i;:::-;11528:2;11523:3;11519:12;11512:19;;11171:366;;;:::o;11543:419::-;11709:4;11747:2;11736:9;11732:18;11724:26;;11796:9;11790:4;11786:20;11782:1;11771:9;11767:17;11760:47;11824:131;11950:4;11824:131;:::i;:::-;11816:139;;11543:419;;;:::o;11968:168::-;12051:11;12085:6;12080:3;12073:19;12125:4;12120:3;12116:14;12101:29;;11968:168;;;;:::o;12142:180::-;12282:32;12278:1;12270:6;12266:14;12259:56;12142:180;:::o;12328:364::-;12469:3;12490:66;12553:2;12548:3;12490:66;:::i;:::-;12483:73;;12565:93;12654:3;12565:93;:::i;:::-;12683:2;12678:3;12674:12;12667:19;;12328:364;;;:::o;12698:748::-;12947:4;12985:3;12974:9;12970:19;12962:27;;12999:71;13067:1;13056:9;13052:17;13043:6;12999:71;:::i;:::-;13080:72;13148:2;13137:9;13133:18;13124:6;13080:72;:::i;:::-;13162;13230:2;13219:9;13215:18;13206:6;13162:72;:::i;:::-;13281:9;13275:4;13271:20;13266:2;13255:9;13251:18;13244:48;13309:130;13434:4;13309:130;:::i;:::-;13301:138;;12698:748;;;;;;:::o;13452:233::-;13491:3;13514:24;13532:5;13514:24;:::i;:::-;13505:33;;13560:66;13553:5;13550:77;13547:103;;;13630:18;;:::i;:::-;13547:103;13677:1;13670:5;13666:13;13659:20;;13452:233;;;:::o;13691:182::-;13831:34;13827:1;13819:6;13815:14;13808:58;13691:182;:::o;13879:366::-;14021:3;14042:67;14106:2;14101:3;14042:67;:::i;:::-;14035:74;;14118:93;14207:3;14118:93;:::i;:::-;14236:2;14231:3;14227:12;14220:19;;13879:366;;;:::o;14251:419::-;14417:4;14455:2;14444:9;14440:18;14432:26;;14504:9;14498:4;14494:20;14490:1;14479:9;14475:17;14468:47;14532:131;14658:4;14532:131;:::i;:::-;14524:139;;14251:419;;;:::o;14676:178::-;14816:30;14812:1;14804:6;14800:14;14793:54;14676:178;:::o;14860:366::-;15002:3;15023:67;15087:2;15082:3;15023:67;:::i;:::-;15016:74;;15099:93;15188:3;15099:93;:::i;:::-;15217:2;15212:3;15208:12;15201:19;;14860:366;;;:::o;15232:419::-;15398:4;15436:2;15425:9;15421:18;15413:26;;15485:9;15479:4;15475:20;15471:1;15460:9;15456:17;15449:47;15513:131;15639:4;15513:131;:::i;:::-;15505:139;;15232:419;;;:::o;15657:179::-;15797:31;15793:1;15785:6;15781:14;15774:55;15657:179;:::o;15842:364::-;15983:3;16004:66;16067:2;16062:3;16004:66;:::i;:::-;15997:73;;16079:93;16168:3;16079:93;:::i;:::-;16197:2;16192:3;16188:12;16181:19;;15842:364;;;:::o;16212:748::-;16461:4;16499:3;16488:9;16484:19;16476:27;;16513:71;16581:1;16570:9;16566:17;16557:6;16513:71;:::i;:::-;16594:72;16662:2;16651:9;16647:18;16638:6;16594:72;:::i;:::-;16676;16744:2;16733:9;16729:18;16720:6;16676:72;:::i;:::-;16795:9;16789:4;16785:20;16780:2;16769:9;16765:18;16758:48;16823:130;16948:4;16823:130;:::i;:::-;16815:138;;16212:748;;;;;;:::o;16966:102::-;17007:6;17058:2;17054:7;17049:2;17042:5;17038:14;17034:28;17024:38;;16966:102;;;:::o;17074:180::-;17122:77;17119:1;17112:88;17219:4;17216:1;17209:15;17243:4;17240:1;17233:15;17260:281;17343:27;17365:4;17343:27;:::i;:::-;17335:6;17331:40;17473:6;17461:10;17458:22;17437:18;17425:10;17422:34;17419:62;17416:88;;;17484:18;;:::i;:::-;17416:88;17524:10;17520:2;17513:22;17303:238;17260:281;;:::o;17547:129::-;17581:6;17608:20;;:::i;:::-;17598:30;;17637:33;17665:4;17657:6;17637:33;:::i;:::-;17547:129;;;:::o;17682:311::-;17759:4;17849:18;17841:6;17838:30;17835:56;;;17871:18;;:::i;:::-;17835:56;17921:4;17913:6;17909:17;17901:25;;17981:4;17975;17971:15;17963:23;;17682:311;;;:::o;17999:143::-;18056:5;18087:6;18081:13;18072:22;;18103:33;18130:5;18103:33;:::i;:::-;17999:143;;;;:::o;18165:732::-;18272:5;18297:81;18313:64;18370:6;18313:64;:::i;:::-;18297:81;:::i;:::-;18288:90;;18398:5;18427:6;18420:5;18413:21;18461:4;18454:5;18450:16;18443:23;;18514:4;18506:6;18502:17;18494:6;18490:30;18543:3;18535:6;18532:15;18529:122;;;18562:79;;:::i;:::-;18529:122;18677:6;18660:231;18694:6;18689:3;18686:15;18660:231;;;18769:3;18798:48;18842:3;18830:10;18798:48;:::i;:::-;18793:3;18786:61;18876:4;18871:3;18867:14;18860:21;;18736:155;18720:4;18715:3;18711:14;18704:21;;18660:231;;;18664:21;18278:619;;18165:732;;;;;:::o;18920:385::-;19002:5;19051:3;19044:4;19036:6;19032:17;19028:27;19018:122;;19059:79;;:::i;:::-;19018:122;19169:6;19163:13;19194:105;19295:3;19287:6;19280:4;19272:6;19268:17;19194:105;:::i;:::-;19185:114;;19008:297;18920:385;;;;:::o;19311:554::-;19406:6;19455:2;19443:9;19434:7;19430:23;19426:32;19423:119;;;19461:79;;:::i;:::-;19423:119;19602:1;19591:9;19587:17;19581:24;19632:18;19624:6;19621:30;19618:117;;;19654:79;;:::i;:::-;19618:117;19759:89;19840:7;19831:6;19820:9;19816:22;19759:89;:::i;:::-;19749:99;;19552:306;19311:554;;;;:::o;19871:170::-;20011:22;20007:1;19999:6;19995:14;19988:46;19871:170;:::o;20047:366::-;20189:3;20210:67;20274:2;20269:3;20210:67;:::i;:::-;20203:74;;20286:93;20375:3;20286:93;:::i;:::-;20404:2;20399:3;20395:12;20388:19;;20047:366;;;:::o;20419:419::-;20585:4;20623:2;20612:9;20608:18;20600:26;;20672:9;20666:4;20662:20;20658:1;20647:9;20643:17;20636:47;20700:131;20826:4;20700:131;:::i;:::-;20692:139;;20419:419;;;:::o;20844:305::-;20884:3;20903:20;20921:1;20903:20;:::i;:::-;20898:25;;20937:20;20955:1;20937:20;:::i;:::-;20932:25;;21091:1;21023:66;21019:74;21016:1;21013:81;21010:107;;;21097:18;;:::i;:::-;21010:107;21141:1;21138;21134:9;21127:16;;20844:305;;;;:::o;21155:332::-;21276:4;21314:2;21303:9;21299:18;21291:26;;21327:71;21395:1;21384:9;21380:17;21371:6;21327:71;:::i;:::-;21408:72;21476:2;21465:9;21461:18;21452:6;21408:72;:::i;:::-;21155:332;;;;;:::o;21493:116::-;21563:21;21578:5;21563:21;:::i;:::-;21556:5;21553:32;21543:60;;21599:1;21596;21589:12;21543:60;21493:116;:::o;21615:137::-;21669:5;21700:6;21694:13;21685:22;;21716:30;21740:5;21716:30;:::i;:::-;21615:137;;;;:::o;21758:345::-;21825:6;21874:2;21862:9;21853:7;21849:23;21845:32;21842:119;;;21880:79;;:::i;:::-;21842:119;22000:1;22025:61;22078:7;22069:6;22058:9;22054:22;22025:61;:::i;:::-;22015:71;;21971:125;21758:345;;;;:::o;22109:351::-;22179:6;22228:2;22216:9;22207:7;22203:23;22199:32;22196:119;;;22234:79;;:::i;:::-;22196:119;22354:1;22379:64;22435:7;22426:6;22415:9;22411:22;22379:64;:::i;:::-;22369:74;;22325:128;22109:351;;;;:::o;22466:164::-;22606:16;22602:1;22594:6;22590:14;22583:40;22466:164;:::o;22636:366::-;22778:3;22799:67;22863:2;22858:3;22799:67;:::i;:::-;22792:74;;22875:93;22964:3;22875:93;:::i;:::-;22993:2;22988:3;22984:12;22977:19;;22636:366;;;:::o;23008:419::-;23174:4;23212:2;23201:9;23197:18;23189:26;;23261:9;23255:4;23251:20;23247:1;23236:9;23232:17;23225:47;23289:131;23415:4;23289:131;:::i;:::-;23281:139;;23008:419;;;:::o;23433:348::-;23473:7;23496:20;23514:1;23496:20;:::i;:::-;23491:25;;23530:20;23548:1;23530:20;:::i;:::-;23525:25;;23718:1;23650:66;23646:74;23643:1;23640:81;23635:1;23628:9;23621:17;23617:105;23614:131;;;23725:18;;:::i;:::-;23614:131;23773:1;23770;23766:9;23755:20;;23433:348;;;;:::o;23787:225::-;23927:34;23923:1;23915:6;23911:14;23904:58;23996:8;23991:2;23983:6;23979:15;23972:33;23787:225;:::o;24018:366::-;24160:3;24181:67;24245:2;24240:3;24181:67;:::i;:::-;24174:74;;24257:93;24346:3;24257:93;:::i;:::-;24375:2;24370:3;24366:12;24359:19;;24018:366;;;:::o;24390:419::-;24556:4;24594:2;24583:9;24579:18;24571:26;;24643:9;24637:4;24633:20;24629:1;24618:9;24614:17;24607:47;24671:131;24797:4;24671:131;:::i;:::-;24663:139;;24390:419;;;:::o;24815:170::-;24955:22;24951:1;24943:6;24939:14;24932:46;24815:170;:::o;24991:366::-;25133:3;25154:67;25218:2;25213:3;25154:67;:::i;:::-;25147:74;;25230:93;25319:3;25230:93;:::i;:::-;25348:2;25343:3;25339:12;25332:19;;24991:366;;;:::o;25363:419::-;25529:4;25567:2;25556:9;25552:18;25544:26;;25616:9;25610:4;25606:20;25602:1;25591:9;25587:17;25580:47;25644:131;25770:4;25644:131;:::i;:::-;25636:139;;25363:419;;;:::o;25788:180::-;25836:77;25833:1;25826:88;25933:4;25930:1;25923:15;25957:4;25954:1;25947:15

ipfs://21c75c1fb61eb76d5810edb4c9ecc45bd43c3a11d655e0198376294be9f25297