Contract 0x809faf2bf3c1c8c2dd64c5cdfef1ae6a524b8166 1

/**
 *Submitted for verification at polygonscan.com on 2022-04-29
*/

// Dependency file: @openzeppelin/contracts/utils/Strings.sol

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)

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


// Dependency file: @openzeppelin/contracts/utils/cryptography/ECDSA.sol

// OpenZeppelin Contracts v4.4.1 (utils/cryptography/ECDSA.sol)

// pragma solidity ^0.8.0;

// import "@openzeppelin/contracts/utils/Strings.sol";

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        } else if (error == RecoverError.InvalidSignatureV) {
            revert("ECDSA: invalid signature 'v' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        // Check the signature length
        // - case 65: r,s,v signature (standard)
        // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else if (signature.length == 64) {
            bytes32 r;
            bytes32 vs;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                vs := mload(add(signature, 0x40))
            }
            return tryRecover(hash, r, vs);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s;
        uint8 v;
        assembly {
            s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
            v := add(shr(255, vs), 27)
        }
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }
        if (v != 27 && v != 28) {
            return (address(0), RecoverError.InvalidSignatureV);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}


// Dependency file: @openzeppelin/contracts/token/ERC20/IERC20.sol

// OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol)

// pragma solidity ^0.8.0;

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

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

    /**
     * @dev Moves `amount` tokens from the caller's account to `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);
}


// Dependency file: @openzeppelin/contracts/utils/introspection/IERC165.sol

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

// pragma solidity ^0.8.0;

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


// Dependency file: @openzeppelin/contracts/token/ERC721/IERC721.sol

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

// pragma solidity ^0.8.0;

// import "@openzeppelin/contracts/utils/introspection/IERC165.sol";

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


// Dependency file: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol

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

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


// Dependency file: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol

// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

// pragma solidity ^0.8.0;

// import "@openzeppelin/contracts/token/ERC721/IERC721.sol";

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


// Dependency file: @openzeppelin/contracts/utils/Address.sol

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

// pragma solidity ^0.8.0;

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

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}


// Dependency file: @openzeppelin/contracts/utils/Context.sol

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

// pragma solidity ^0.8.0;

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

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


// Dependency file: @openzeppelin/contracts/utils/introspection/ERC165.sol

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

// pragma solidity ^0.8.0;

// import "@openzeppelin/contracts/utils/introspection/IERC165.sol";

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


// Dependency file: @openzeppelin/contracts/token/ERC721/ERC721.sol

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

// pragma solidity ^0.8.0;

// import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
// import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
// import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
// import "@openzeppelin/contracts/utils/Address.sol";
// import "@openzeppelin/contracts/utils/Context.sol";
// import "@openzeppelin/contracts/utils/Strings.sol";
// import "@openzeppelin/contracts/utils/introspection/ERC165.sol";

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


// Dependency file: @openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol

// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Enumerable.sol)

// pragma solidity ^0.8.0;

// import "@openzeppelin/contracts/token/ERC721/IERC721.sol";

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


// Dependency file: @openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol

// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/ERC721Enumerable.sol)

// pragma solidity ^0.8.0;

// import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
// import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";

/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
 * enumerability of all the token ids in the contract as well as all token ids owned by each
 * account.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

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

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
        return _ownedTokens[owner][index];
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _allTokens.length;
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
        return _allTokens[index];
    }

    /**
     * @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` cannot be the zero address.
     * - `to` cannot be the zero address.
     *
     * 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 override {
        super._beforeTokenTransfer(from, to, tokenId);

        if (from == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (from != to) {
            _removeTokenFromOwnerEnumeration(from, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (to != from) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = ERC721.balanceOf(to);
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }
}


// Dependency file: @openzeppelin/contracts/security/ReentrancyGuard.sol

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

// pragma solidity ^0.8.0;

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

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

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

        _;

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


// Dependency file: @openzeppelin/contracts/access/Ownable.sol

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

// pragma solidity ^0.8.0;

// import "@openzeppelin/contracts/utils/Context.sol";

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

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

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

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


// Root file: contracts/GrabCoinClub.sol

pragma solidity ^0.8.0;

// import "@openzeppelin/contracts/utils/Strings.sol";
// import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
// import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
// import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
// import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
// import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
// import "@openzeppelin/contracts/access/Ownable.sol";

contract GrabCoinClub is ERC721, ERC721Enumerable, ReentrancyGuard, Ownable {
    using Strings for uint256;

    uint256 public constant maxSupply = 15555;
    uint256 public mintLimit = 5; // TODO
    uint256 public mintPresaleLimit = 1; // TODO
    mapping(uint256 => uint256) public mintedAt;
    mapping(address => mapping(uint256 => uint256)) public mintsOf;
    mapping(address => mapping(uint256 => uint256)) public mintsPresaleOf;
    mapping(address => uint256) public mintNonce;

    // Series
    struct Series {
        uint256 id;
        bool unlocked;
        uint256 next;
        uint256 last;
    }
    uint256 public constant seriesTotal = 15;
    Series[seriesTotal] public series;

    // Metadata
    string public contractURI; // TODO
    string public baseURI; // TODO
    string public baseExtension = ".json";

    // Addresses
    address public admin = 0x833A386DbF31b5CA853b418716ADD0F5511A365b; // TODO
    address public signer = 0x0E52Bee0EF46ed96F2CA50Ea22B5C1B5C750a1d4; // TODO
    address public wallet = 0x92c8a2B4E36eCa320909387B6EdA9867a6Fc214E; // TODO

    constructor() ERC721("GrabCoinClub", "GCC") {
        uint256[seriesTotal] memory series_ = [
            uint256(3000),
            uint256(2800),
            uint256(2300),
            uint256(2000),
            uint256(1700),
            uint256(1500),
            uint256(1000),
            uint256(550),
            uint256(300),
            uint256(200),
            uint256(100),
            uint256(50),
            uint256(25),
            uint256(20),
            uint256(10)
        ];
        uint256 last = 0;
        for (uint256 i = 0; i < series_.length; i++) {
            series[i] = Series(i, i < 7, last, last += series_[i]);
        }
    }

    // Mint
    function mintAdmin(uint256 series_, uint256 quantity_) public onlyAdmin {
        _internalMint(series_, quantity_, _msgSender());
    }

    function mintAirdrop(uint256 series_, address[] memory accounts_)
        public
        onlyAdmin
    {
        for (uint256 i = 0; i < accounts_.length; i++) {
            _internalMint(series_, 1, accounts_[i]);
        }
    }

    function mintPresale(
        uint256 series_,
        uint256 quantity_,
        address tokenAddress_,
        uint256 amount_,
        uint256 nonce_,
        bytes memory signature_
    ) public payable {
        _checkSignature(
            _msgSender(),
            series_,
            quantity_,
            tokenAddress_,
            amount_,
            nonce_,
            signature_
        );
        _distribute(_msgSender(), tokenAddress_, amount_);
        _internalMintWithLimit(
            series_,
            quantity_,
            _msgSender(),
            mintPresaleLimit,
            mintsPresaleOf[_msgSender()][series_]
        );
        mintsPresaleOf[_msgSender()][series_] += quantity_;
    }

    function mint(
        uint256 series_,
        uint256 quantity_,
        address tokenAddress_,
        uint256 amount_,
        uint256 nonce_,
        bytes memory signature_
    ) public payable {
        _checkSignature(
            _msgSender(),
            series_,
            quantity_,
            tokenAddress_,
            amount_,
            nonce_,
            signature_
        );
        _distribute(_msgSender(), tokenAddress_, amount_);
        _internalMintWithLimit(
            series_,
            quantity_,
            _msgSender(),
            mintLimit,
            mintsOf[_msgSender()][series_]
        );
        mintsOf[_msgSender()][series_] += quantity_;
    }

    function _internalMintWithLimit(
        uint256 series_,
        uint256 quantity_,
        address account_,
        uint256 mintLimit_,
        uint256 mints_
    ) private {
        require(mints_ + quantity_ <= mintLimit_, "Mint limit");
        _internalMint(series_, quantity_, account_);
    }

    function _internalMint(
        uint256 series_,
        uint256 quantity_,
        address account_
    ) private nonReentrant {
        require(series[series_].unlocked, "Series locked");
        require(
            series[series_].next + quantity_ <= series[series_].last,
            "Out of bounds"
        );

        for (uint256 i = 0; i < quantity_; i++) {
            uint256 tokenId = series[series_].next++;
            _safeMint(account_, tokenId);
            mintedAt[tokenId] = block.timestamp;
        }
    }

    function _distribute(
        address from_,
        address tokenAddress_,
        uint256 amount_
    ) private {
        if (tokenAddress_ == address(0) && amount_ > 0) {
            _sendEth(wallet, amount_);
        } else if (amount_ > 0) {
            IERC20(tokenAddress_).transferFrom(from_, address(this), amount_);
            _sendErc20(tokenAddress_, wallet, amount_);
        }
    }

    function setMintLimit(uint256 newMintLimit) public onlyOwner {
        mintLimit = newMintLimit;
    }

    function setMintPresaleLimit(uint256 newMintPresaleLimit) public onlyOwner {
        mintPresaleLimit = newMintPresaleLimit;
    }

    // Overrides
    function tokenURI(uint256 tokenId)
        public
        view
        override
        returns (string memory)
    {
        require(
            _exists(tokenId),
            "ERC721Metadata: URI query for nonexistent token"
        );

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

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal override(ERC721, ERC721Enumerable) {
        super._beforeTokenTransfer(from, to, tokenId);
    }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(ERC721, ERC721Enumerable)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }

    // Extra
    function rawOwnerOf(uint256 tokenId) public view returns (address) {
        if (_exists(tokenId)) return ownerOf(tokenId);
        return address(0);
    }

    function tokensOfOwner(address owner)
        public
        view
        returns (uint256[] memory)
    {
        uint256 balance = balanceOf(owner);
        require(0 < balance, "ERC721Enumerable: owner index out of bounds");
        uint256[] memory tokenIds = new uint256[](balance);
        for (uint256 i = 0; i < balance; i++) {
            tokenIds[i] = tokenOfOwnerByIndex(owner, i);
        }
        return tokenIds;
    }

    // Metadata
    function setContractURI(string memory contractURI_) public onlyOwner {
        contractURI = contractURI_;
    }

    function setBaseURI(string memory baseURI_) public onlyOwner {
        baseURI = baseURI_;
    }

    function setBaseExtension(string memory baseExtension_) public onlyOwner {
        baseExtension = baseExtension_;
    }

    // Series
    function seriesOf(uint256 tokenId) public view returns (uint256 seriesId) {
        require(tokenId < maxSupply, "Out of bounds");
        for (uint256 i = 0; i < series.length; i++) {
            if (tokenId < series[i].last) {
                return i;
            }
        }
    }

    function unlock(uint256 series_) public onlyOwner {
        series[series_].unlocked = true;
    }

    // Admin
    modifier onlyAdmin() {
        require(admin == _msgSender(), "Caller is not the admin");
        _;
    }

    function setAdmin(address newAdmin) public onlyOwner {
        admin = newAdmin;
    }

    // Signature
    function setSigner(address newSigner) public onlyOwner {
        signer = newSigner;
    }

    function signatureWallet(
        address wallet_,
        uint256 series_,
        uint256 quantity_,
        address tokenAddress_,
        uint256 amount_,
        uint256 nonce_,
        bytes memory signature_
    ) public pure returns (address) {
        return
            ECDSA.recover(
                keccak256(
                    abi.encode(
                        wallet_,
                        series_,
                        quantity_,
                        tokenAddress_,
                        amount_,
                        nonce_
                    )
                ),
                signature_
            );
    }

    function _checkSignature(
        address wallet_,
        uint256 series_,
        uint256 quantity_,
        address tokenAddress_,
        uint256 amount_,
        uint256 nonce_,
        bytes memory signature_
    ) private {
        require(
            mintNonce[wallet_] < nonce_,
            "Can not repeat a prior transaction!"
        );
        require(
            signatureWallet(
                wallet_,
                series_,
                quantity_,
                tokenAddress_,
                amount_,
                nonce_,
                signature_
            ) == signer,
            "Not authorized to mint"
        );
        mintNonce[wallet_] = nonce_;
    }

    // withdraw
    function setWallet(address newWallet) public onlyOwner {
        wallet = newWallet;
    }

    function withdraw(address to, uint256 amount) public onlyOwner {
        _sendEth(to, amount);
    }

    function withdrawErc20(
        address token,
        address to,
        uint256 amount
    ) public onlyOwner {
        _sendErc20(token, to, amount);
    }

    function _sendEth(address recipient, uint256 amount) private {
        (bool success, ) = recipient.call{value: amount}("");
        require(success, "ETH_TRANSFER_FAILED");
    }

    function _sendErc20(
        address tokenAddress,
        address recipient,
        uint256 amount
    ) private {
        // bytes4(keccak256(bytes('transfer(address,uint256)')));
        (bool success, bytes memory data) = tokenAddress.call(
            abi.encodeWithSelector(0xa9059cbb, recipient, amount)
        );
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            "ERC20_TRANSFER_FAILED"
        );
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"admin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseExtension","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"series_","type":"uint256"},{"internalType":"uint256","name":"quantity_","type":"uint256"},{"internalType":"address","name":"tokenAddress_","type":"address"},{"internalType":"uint256","name":"amount_","type":"uint256"},{"internalType":"uint256","name":"nonce_","type":"uint256"},{"internalType":"bytes","name":"signature_","type":"bytes"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"series_","type":"uint256"},{"internalType":"uint256","name":"quantity_","type":"uint256"}],"name":"mintAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"series_","type":"uint256"},{"internalType":"address[]","name":"accounts_","type":"address[]"}],"name":"mintAirdrop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"mintLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"mintNonce","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"series_","type":"uint256"},{"internalType":"uint256","name":"quantity_","type":"uint256"},{"internalType":"address","name":"tokenAddress_","type":"address"},{"internalType":"uint256","name":"amount_","type":"uint256"},{"internalType":"uint256","name":"nonce_","type":"uint256"},{"internalType":"bytes","name":"signature_","type":"bytes"}],"name":"mintPresale","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintPresaleLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"mintedAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"mintsOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"mintsPresaleOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"rawOwnerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"series","outputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"bool","name":"unlocked","type":"bool"},{"internalType":"uint256","name":"next","type":"uint256"},{"internalType":"uint256","name":"last","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"seriesOf","outputs":[{"internalType":"uint256","name":"seriesId","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"seriesTotal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newAdmin","type":"address"}],"name":"setAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseExtension_","type":"string"}],"name":"setBaseExtension","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI_","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"contractURI_","type":"string"}],"name":"setContractURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newMintLimit","type":"uint256"}],"name":"setMintLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newMintPresaleLimit","type":"uint256"}],"name":"setMintPresaleLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newSigner","type":"address"}],"name":"setSigner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newWallet","type":"address"}],"name":"setWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"wallet_","type":"address"},{"internalType":"uint256","name":"series_","type":"uint256"},{"internalType":"uint256","name":"quantity_","type":"uint256"},{"internalType":"address","name":"tokenAddress_","type":"address"},{"internalType":"uint256","name":"amount_","type":"uint256"},{"internalType":"uint256","name":"nonce_","type":"uint256"},{"internalType":"bytes","name":"signature_","type":"bytes"}],"name":"signatureWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"signer","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"tokensOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"series_","type":"uint256"}],"name":"unlock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"wallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawErc20","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

61367:10429:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67325:212;;;;;;;;;;-1:-1:-1;67325:212:0;;;;;:::i;:::-;;:::i;:::-;;;611:14:1;;604:22;586:41;;574:2;559:18;67325:212:0;;;;;;;;64349:721;;;;;;:::i;:::-;;:::i;:::-;;35504:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;37063:221::-;;;;;;;;;;-1:-1:-1;37063:221:0;;;;;:::i;:::-;;:::i;:::-;;;3907:42:1;3895:55;;;3877:74;;3865:2;3850:18;37063:221:0;3731:226:1;36586:411:0;;;;;;;;;;-1:-1:-1;36586:411:0;;;;;:::i;:::-;;:::i;63347:237::-;;;;;;;;;;-1:-1:-1;63347:237:0;;;;;:::i;:::-;;:::i;70954:165::-;;;;;;;;;;-1:-1:-1;70954:165:0;;;;;:::i;:::-;;:::i;49958:113::-;;;;;;;;;;-1:-1:-1;50046:10:0;:17;49958:113;;;5725:25:1;;;5713:2;5698:18;49958:113:0;5579:177:1;62333:66:0;;;;;;;;;;-1:-1:-1;62333:66:0;;;;;;;;37813:339;;;;;;;;;;-1:-1:-1;37813:339:0;;;;;:::i;:::-;;:::i;66475:132::-;;;;;;;;;;-1:-1:-1;66475:132:0;;;;;:::i;:::-;;:::i;49626:256::-;;;;;;;;;;-1:-1:-1;49626:256:0;;;;;:::i;:::-;;:::i;61820:44::-;;;;;;;;;;-1:-1:-1;61820:44:0;;;;;:::i;:::-;;;;;;;;;;;;;;38223:185;;;;;;;;;;-1:-1:-1;38223:185:0;;;;;:::i;:::-;;:::i;62007:40::-;;;;;;;;;;;;62045:2;62007:40;;50148:233;;;;;;;;;;-1:-1:-1;50148:233:0;;;;;:::i;:::-;;:::i;62414:66::-;;;;;;;;;;-1:-1:-1;62414:66:0;;;;;;;;68318:98;;;;;;;;;;-1:-1:-1;68318:98:0;;;;;:::i;:::-;;:::i;68868:100::-;;;;;;;;;;-1:-1:-1;68868:100:0;;;;;:::i;:::-;;:::i;35198:239::-;;;;;;;;;;-1:-1:-1;35198:239:0;;;;;:::i;:::-;;:::i;62153:21::-;;;;;;;;;;;;;:::i;69221:92::-;;;;;;;;;;-1:-1:-1;69221:92:0;;;;;:::i;:::-;;:::i;69107:88::-;;;;;;;;;;-1:-1:-1;69107:88:0;;;;;:::i;:::-;;:::i;34928:208::-;;;;;;;;;;-1:-1:-1;34928:208:0;;;;;:::i;:::-;;:::i;60022:103::-;;;;;;;;;;;;;:::i;61675:62::-;;;;;;;;;;-1:-1:-1;61675:62:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;67559:159;;;;;;;;;;-1:-1:-1;67559:159:0;;;;;:::i;:::-;;:::i;67726:445::-;;;;;;;;;;-1:-1:-1;67726:445:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;59371:87::-;;;;;;;;;;-1:-1:-1;59444:6:0;;;;59371:87;;68196:114;;;;;;;;;;-1:-1:-1;68196:114:0;;;;;:::i;:::-;;:::i;35673:104::-;;;;;;;;;;;;;:::i;61532:28::-;;;;;;;;;;;;;;;;66363:104;;;;;;;;;;-1:-1:-1;66363:104:0;;;;;:::i;:::-;;:::i;37356:155::-;;;;;;;;;;-1:-1:-1;37356:155:0;;;;;:::i;:::-;;:::i;63201:138::-;;;;;;;;;;-1:-1:-1;63201:138:0;;;;;:::i;:::-;;:::i;38479:328::-;;;;;;;;;;-1:-1:-1;38479:328:0;;;;;:::i;:::-;;:::i;62189:37::-;;;;;;;;;;;;;:::i;66633:461::-;;;;;;;;;;-1:-1:-1;66633:461:0;;;;;:::i;:::-;;:::i;69321:669::-;;;;;;;;;;-1:-1:-1;69321:669:0;;;;;:::i;:::-;;:::i;61744:69::-;;;;;;;;;;-1:-1:-1;61744:69:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;61575:35;;;;;;;;;;;;;;;;61484:41;;;;;;;;;;;;61520:5;61484:41;;68424:122;;;;;;;;;;-1:-1:-1;68424:122:0;;;;;:::i;:::-;;:::i;63592:749::-;;;;;;:::i;:::-;;:::i;62054:33::-;;;;;;;;;;-1:-1:-1;62054:33:0;;;;;:::i;:::-;;:::i;:::-;;;;9256:25:1;;;9324:14;;9317:22;9312:2;9297:18;;9290:50;9356:18;;;9349:34;9414:2;9399:18;;9392:34;9243:3;9228:19;62054:33:0;9031:401:1;70744:92:0;;;;;;;;;;-1:-1:-1;70744:92:0;;;;;:::i;:::-;;:::i;68569:291::-;;;;;;;;;;-1:-1:-1;68569:291:0;;;;;:::i;:::-;;:::i;62113:25::-;;;;;;;;;;;;;:::i;37582:164::-;;;;;;;;;;-1:-1:-1;37582:164:0;;;;;:::i;:::-;37703:25;;;;37679:4;37703:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;37582:164;61625:43;;;;;;;;;;-1:-1:-1;61625:43:0;;;;;:::i;:::-;;;;;;;;;;;;;;60280:201;;;;;;;;;;-1:-1:-1;60280:201:0;;;;;:::i;:::-;;:::i;70844:102::-;;;;;;;;;;-1:-1:-1;70844:102:0;;;;;:::i;:::-;;:::i;62253:65::-;;;;;;;;;;-1:-1:-1;62253:65:0;;;;;;;;67325:212;67464:4;67493:36;67517:11;67493:23;:36::i;:::-;67486:43;67325:212;-1:-1:-1;;67325:212:0:o;64349:721::-;64567:195;31465:10;64597:12;64624:7;64646:9;64670:13;64698:7;64720:6;64741:10;64567:15;:195::i;:::-;64773:49;31465:10;64785:12;64799:13;64814:7;64773:11;:49::i;:::-;64833:175;64870:7;64892:9;31465:10;64943:9;;64967:7;:21;31465:10;64975:12;64967:21;;;;;;;;;;;;;;;:30;64989:7;64967:30;;;;;;;;;;;;64833:22;:175::i;:::-;65053:9;65019:7;:21;31465:10;65027:12;65019:21;;;;;;;;;;;;;;;:30;65041:7;65019:30;;;;;;;;;;;;:43;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;;64349:721:0:o;35504:100::-;35558:13;35591:5;35584:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35504:100;:::o;37063:221::-;37139:7;40406:16;;;:7;:16;;;;;;:30;:16;37159:73;;;;;;;10668:2:1;37159:73:0;;;10650:21:1;10707:2;10687:18;;;10680:30;10746:34;10726:18;;;10719:62;10817:14;10797:18;;;10790:42;10849:19;;37159:73:0;;;;;;;;;-1:-1:-1;37252:24:0;;;;:15;:24;;;;;;;;;37063:221::o;36586:411::-;36667:13;36683:23;36698:7;36683:14;:23::i;:::-;36667:39;;36731:5;36725:11;;:2;:11;;;;36717:57;;;;;;;11081:2:1;36717:57:0;;;11063:21:1;11120:2;11100:18;;;11093:30;11159:34;11139:18;;;11132:62;11230:3;11210:18;;;11203:31;11251:19;;36717:57:0;10879:397:1;36717:57:0;31465:10;36809:21;;;;;:62;;-1:-1:-1;36834:37:0;36851:5;31465:10;37582:164;:::i;36834:37::-;36787:168;;;;;;;11483:2:1;36787:168:0;;;11465:21:1;11522:2;11502:18;;;11495:30;11561:34;11541:18;;;11534:62;11632:26;11612:18;;;11605:54;11676:19;;36787:168:0;11281:420:1;36787:168:0;36968:21;36977:2;36981:7;36968:8;:21::i;:::-;36656:341;36586:411;;:::o;63347:237::-;69030:5;;:21;:5;31465:10;69030:21;69022:57;;;;;;;11908:2:1;69022:57:0;;;11890:21:1;11947:2;11927:18;;;11920:30;11986:25;11966:18;;;11959:53;12029:18;;69022:57:0;11706:347:1;69022:57:0;63469:9:::1;63464:113;63488:9;:16;63484:1;:20;63464:113;;;63526:39;63540:7;63549:1;63552:9;63562:1;63552:12;;;;;;;;:::i;:::-;;;;;;;63526:13;:39::i;:::-;63506:3:::0;::::1;::::0;::::1;:::i;:::-;;;;63464:113;;70954:165:::0;59444:6;;59591:23;59444:6;31465:10;59591:23;59583:68;;;;;;;12649:2:1;59583:68:0;;;12631:21:1;;;12668:18;;;12661:30;12727:34;12707:18;;;12700:62;12779:18;;59583:68:0;12447:356:1;59583:68:0;71082:29:::1;71093:5;71100:2;71104:6;71082:10;:29::i;37813:339::-:0;38008:41;31465:10;38041:7;38008:18;:41::i;:::-;38000:103;;;;;;;13010:2:1;38000:103:0;;;12992:21:1;13049:2;13029:18;;;13022:30;13088:34;13068:18;;;13061:62;13159:19;13139:18;;;13132:47;13196:19;;38000:103:0;12808:413:1;38000:103:0;38116:28;38126:4;38132:2;38136:7;38116:9;:28::i;66475:132::-;59444:6;;59591:23;59444:6;31465:10;59591:23;59583:68;;;;;;;12649:2:1;59583:68:0;;;12631:21:1;;;12668:18;;;12661:30;12727:34;12707:18;;;12700:62;12779:18;;59583:68:0;12447:356:1;59583:68:0;66561:16:::1;:38:::0;66475:132::o;49626:256::-;49723:7;49759:23;49776:5;49759:16;:23::i;:::-;49751:5;:31;49743:87;;;;;;;13428:2:1;49743:87:0;;;13410:21:1;13467:2;13447:18;;;13440:30;13506:34;13486:18;;;13479:62;13577:13;13557:18;;;13550:41;13608:19;;49743:87:0;13226:407:1;49743:87:0;-1:-1:-1;49848:19:0;;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;49626:256::o;38223:185::-;38361:39;38378:4;38384:2;38388:7;38361:39;;;;;;;;;;;;:16;:39::i;50148:233::-;50223:7;50259:30;50046:10;:17;;49958:113;50259:30;50251:5;:38;50243:95;;;;;;;13840:2:1;50243:95:0;;;13822:21:1;13879:2;13859:18;;;13852:30;13918:34;13898:18;;;13891:62;13989:14;13969:18;;;13962:42;14021:19;;50243:95:0;13638:408:1;50243:95:0;50356:10;50367:5;50356:17;;;;;;;;:::i;:::-;;;;;;;;;50349:24;;50148:233;;;:::o;68318:98::-;59444:6;;59591:23;59444:6;31465:10;59591:23;59583:68;;;;;;;12649:2:1;59583:68:0;;;12631:21:1;;;12668:18;;;12661:30;12727:34;12707:18;;;12700:62;12779:18;;59583:68:0;12447:356:1;59583:68:0;68390:18;;::::1;::::0;:7:::1;::::0;:18:::1;::::0;::::1;::::0;::::1;:::i;:::-;;68318:98:::0;:::o;68868:100::-;59444:6;;59591:23;59444:6;31465:10;59591:23;59583:68;;;;;;;12649:2:1;59583:68:0;;;12631:21:1;;;12668:18;;;12661:30;12727:34;12707:18;;;12700:62;12779:18;;59583:68:0;12447:356:1;59583:68:0;68956:4:::1;68929:6;68936:7;68929:15;;;;;;;:::i;:::-;;;;:24;;;:31;;;;;;;;;;;;;;;;;;68868:100:::0;:::o;35198:239::-;35270:7;35306:16;;;:7;:16;;;;;;;;35341:19;35333:73;;;;;;;14253:2:1;35333:73:0;;;14235:21:1;14292:2;14272:18;;;14265:30;14331:34;14311:18;;;14304:62;14402:11;14382:18;;;14375:39;14431:19;;35333:73:0;14051:405:1;62153:21:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;69221:92::-;59444:6;;59591:23;59444:6;31465:10;59591:23;59583:68;;;;;;;12649:2:1;59583:68:0;;;12631:21:1;;;12668:18;;;12661:30;12727:34;12707:18;;;12700:62;12779:18;;59583:68:0;12447:356:1;59583:68:0;69287:6:::1;:18:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;69221:92::o;69107:88::-;59444:6;;59591:23;59444:6;31465:10;59591:23;59583:68;;;;;;;12649:2:1;59583:68:0;;;12631:21:1;;;12668:18;;;12661:30;12727:34;12707:18;;;12700:62;12779:18;;59583:68:0;12447:356:1;59583:68:0;69171:5:::1;:16:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;69107:88::o;34928:208::-;35000:7;35028:19;;;35020:74;;;;;;;14663:2:1;35020:74:0;;;14645:21:1;14702:2;14682:18;;;14675:30;14741:34;14721:18;;;14714:62;14812:12;14792:18;;;14785:40;14842:19;;35020:74:0;14461:406:1;35020:74:0;-1:-1:-1;35112:16:0;;;;;;:9;:16;;;;;;;34928:208::o;60022:103::-;59444:6;;59591:23;59444:6;31465:10;59591:23;59583:68;;;;;;;12649:2:1;59583:68:0;;;12631:21:1;;;12668:18;;;12661:30;12727:34;12707:18;;;12700:62;12779:18;;59583:68:0;12447:356:1;59583:68:0;60087:30:::1;60114:1;60087:18;:30::i;:::-;60022:103::o:0;67559:159::-;67617:7;40406:16;;;:7;:16;;;;;;:30;:16;:30;67637:45;;67666:16;67674:7;67666;:16::i;67637:45::-;-1:-1:-1;67708:1:0;;67559:159;-1:-1:-1;67559:159:0:o;67726:445::-;67812:16;67846:15;67864:16;67874:5;67864:9;:16::i;:::-;67846:34;;67903:7;67899:1;:11;67891:67;;;;;;;13428:2:1;67891:67:0;;;13410:21:1;13467:2;13447:18;;;13440:30;13506:34;13486:18;;;13479:62;13577:13;13557:18;;;13550:41;13608:19;;67891:67:0;13226:407:1;67891:67:0;67969:25;68011:7;67997:22;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;67997:22:0;;67969:50;;68035:9;68030:108;68054:7;68050:1;:11;68030:108;;;68097:29;68117:5;68124:1;68097:19;:29::i;:::-;68083:8;68092:1;68083:11;;;;;;;;:::i;:::-;;;;;;;;;;:43;68063:3;;;;:::i;:::-;;;;68030:108;;;-1:-1:-1;68155:8:0;67726:445;-1:-1:-1;;;67726:445:0:o;68196:114::-;59444:6;;59591:23;59444:6;31465:10;59591:23;59583:68;;;;;;;12649:2:1;59583:68:0;;;12631:21:1;;;12668:18;;;12661:30;12727:34;12707:18;;;12700:62;12779:18;;59583:68:0;12447:356:1;59583:68:0;68276:26;;::::1;::::0;:11:::1;::::0;:26:::1;::::0;::::1;::::0;::::1;:::i;35673:104::-:0;35729:13;35762:7;35755:14;;;;;:::i;66363:104::-;59444:6;;59591:23;59444:6;31465:10;59591:23;59583:68;;;;;;;12649:2:1;59583:68:0;;;12631:21:1;;;12668:18;;;12661:30;12727:34;12707:18;;;12700:62;12779:18;;59583:68:0;12447:356:1;59583:68:0;66435:9:::1;:24:::0;66363:104::o;37356:155::-;37451:52;31465:10;37484:8;37494;37451:18;:52::i;63201:138::-;69030:5;;:21;:5;31465:10;69030:21;69022:57;;;;;;;11908:2:1;69022:57:0;;;11890:21:1;11947:2;11927:18;;;11920:30;11986:25;11966:18;;;11959:53;12029:18;;69022:57:0;11706:347:1;69022:57:0;63284:47:::1;63298:7:::0;63307:9;31465:10;63284:13:::1;:47::i;38479:328::-:0;38654:41;31465:10;38687:7;38654:18;:41::i;:::-;38646:103;;;;;;;13010:2:1;38646:103:0;;;12992:21:1;13049:2;13029:18;;;13022:30;13088:34;13068:18;;;13061:62;13159:19;13139:18;;;13132:47;13196:19;;38646:103:0;12808:413:1;38646:103:0;38760:39;38774:4;38780:2;38784:7;38793:5;38760:13;:39::i;:::-;38479:328;;;;:::o;62189:37::-;;;;;;;:::i;66633:461::-;40382:4;40406:16;;;:7;:16;;;;;;66734:13;;40406:30;:16;66765:113;;;;;;;15074:2:1;66765:113:0;;;15056:21:1;15113:2;15093:18;;;15086:30;15152:34;15132:18;;;15125:62;15223:17;15203:18;;;15196:45;15258:19;;66765:113:0;14872:411:1;66765:113:0;66935:1;66917:7;66911:21;;;;;:::i;:::-;;;:25;:175;;;;;;;;;;;;;;;;;67002:7;67011:18;:7;:16;:18::i;:::-;67031:13;66985:60;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;66891:195;66633:461;-1:-1:-1;;66633:461:0:o;69321:669::-;69675:244;;;17265:42:1;17334:15;;;69675:244:0;;;17316:34:1;17366:18;;;17359:34;;;17409:18;;;17402:34;;;17472:15;;;17452:18;;;17445:43;17504:19;;;17497:35;;;17548:19;;;17541:35;;;69571:7:0;;69611:371;;17227:19:1;;69675:244:0;;;;;;;;;;;;69643:295;;;;;;69957:10;69611:13;:371::i;:::-;69591:391;69321:669;-1:-1:-1;;;;;;;;69321:669:0:o;68424:122::-;59444:6;;59591:23;59444:6;31465:10;59591:23;59583:68;;;;;;;12649:2:1;59583:68:0;;;12631:21:1;;;12668:18;;;12661:30;12727:34;12707:18;;;12700:62;12779:18;;59583:68:0;12447:356:1;59583:68:0;68508:30;;::::1;::::0;:13:::1;::::0;:30:::1;::::0;::::1;::::0;::::1;:::i;63592:749::-:0;63817:195;31465:10;63847:12;31385:98;63817:195;64023:49;31465:10;64035:12;31385:98;64023:49;64083:189;64120:7;64142:9;31465:10;64193:16;;64224:14;:28;31465:10;64239:12;31385:98;64083:189;64324:9;64283:14;:28;31465:10;64298:12;31385:98;62054:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;62054:33:0;;;;;:::o;70744:92::-;59444:6;;59591:23;59444:6;31465:10;59591:23;59583:68;;;;;;;12649:2:1;59583:68:0;;;12631:21:1;;;12668:18;;;12661:30;12727:34;12707:18;;;12700:62;12779:18;;59583:68:0;12447:356:1;59583:68:0;70810:6:::1;:18:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;70744:92::o;68569:291::-;68625:16;61520:5;68662:7;:19;68654:45;;;;;;;17789:2:1;68654:45:0;;;17771:21:1;17828:2;17808:18;;;17801:30;17867:15;17847:18;;;17840:43;17900:18;;68654:45:0;17587:337:1;68654:45:0;68715:9;68710:143;68734:13;68730:1;:17;68710:143;;;68783:6;68790:1;68783:9;;;;;;;:::i;:::-;;;;:14;;;68773:7;:24;68769:73;;;68825:1;68569:291;-1:-1:-1;;68569:291:0:o;68769:73::-;68749:3;;;;:::i;:::-;;;;68710:143;;;;68569:291;;;:::o;62113:25::-;;;;;;;:::i;60280:201::-;59444:6;;59591:23;59444:6;31465:10;59591:23;59583:68;;;;;;;12649:2:1;59583:68:0;;;12631:21:1;;;12668:18;;;12661:30;12727:34;12707:18;;;12700:62;12779:18;;59583:68:0;12447:356:1;59583:68:0;60369:22:::1;::::0;::::1;60361:73;;;::::0;::::1;::::0;;18131:2:1;60361:73:0::1;::::0;::::1;18113:21:1::0;18170:2;18150:18;;;18143:30;18209:34;18189:18;;;18182:62;18280:8;18260:18;;;18253:36;18306:19;;60361:73:0::1;17929:402:1::0;60361:73:0::1;60445:28;60464:8;60445:18;:28::i;:::-;60280:201:::0;:::o;70844:102::-;59444:6;;59591:23;59444:6;31465:10;59591:23;59583:68;;;;;;;12649:2:1;59583:68:0;;;12631:21:1;;;12668:18;;;12661:30;12727:34;12707:18;;;12700:62;12779:18;;59583:68:0;12447:356:1;59583:68:0;70918:20:::1;70927:2;70931:6;70918:8;:20::i;49318:224::-:0;49420:4;49444:50;;;49459:35;49444:50;;:90;;;49498:36;49522:11;49498:23;:36::i;69998:721::-;70268:18;;;;;;;:9;:18;;;;;;:27;-1:-1:-1;70246:112:0;;;;;;;18538:2:1;70246:112:0;;;18520:21:1;18577:2;18557:18;;;18550:30;18616:34;18596:18;;;18589:62;18687:5;18667:18;;;18660:33;18710:19;;70246:112:0;18336:399:1;70246:112:0;70617:6;;;;70391:222;70425:7;70451;70477:9;70505:13;70537:7;70563:6;70588:10;70391:15;:222::i;:::-;:232;;;70369:304;;;;;;;18942:2:1;70369:304:0;;;18924:21:1;18981:2;18961:18;;;18954:30;19020:24;19000:18;;;18993:52;19062:18;;70369:304:0;18740:346:1;70369:304:0;-1:-1:-1;70684:18:0;;;;;;;;:9;:18;;;;;:27;;;;-1:-1:-1;;;;69998:721:0:o;65947:408::-;66080:27;;;;:42;;;;;66121:1;66111:7;:11;66080:42;66076:272;;;66148:6;;66139:25;;66148:6;;66156:7;66139:8;:25::i;66076:272::-;66186:11;;66182:166;;66214:65;;;;;:34;19372:15:1;;;66214:65:0;;;19354:34:1;66264:4:0;19404:18:1;;;19397:43;19456:18;;;19449:34;;;66214::0;;;;;19266:18:1;;66214:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;66320:6:0;;66294:42;;66305:13;;66320:6;;66328:7;66294:10;:42::i;65078:310::-;65301:10;65279:18;65288:9;65279:6;:18;:::i;:::-;:32;;65271:55;;;;;;;19946:2:1;65271:55:0;;;19928:21:1;19985:2;19965:18;;;19958:30;20024:12;20004:18;;;19997:40;20054:18;;65271:55:0;19744:334:1;65271:55:0;65337:43;65351:7;65360:9;65371:8;65337:13;:43::i;:::-;65078:310;;;;;:::o;44299:174::-;44374:24;;;;:15;:24;;;;;:29;;;;;;;;;;;;;:24;;44428:23;44374:24;44428:14;:23::i;:::-;44419:46;;;;;;;;;;;;44299:174;;:::o;65396:543::-;57292:1;57890:7;;:19;;57882:63;;;;;;;20285:2:1;57882:63:0;;;20267:21:1;20324:2;20304:18;;;20297:30;20363:33;20343:18;;;20336:61;20414:18;;57882:63:0;20083:355:1;57882:63:0;57292:1;58023:7;:18;65547:6:::1;65554:7:::0;65547:15:::1;::::0;::::1;;;;;:::i;:::-;;;;:24;;::::0;::::1;;65539:50;;;::::0;::::1;::::0;;20645:2:1;65539:50:0::1;::::0;::::1;20627:21:1::0;20684:2;20664:18;;;20657:30;20723:15;20703:18;;;20696:43;20756:18;;65539:50:0::1;20443:337:1::0;65539:50:0::1;65658:6;65665:7;65658:15;;;;;;;:::i;:::-;;;;:20;;;65645:9;65622:6;65629:7;65622:15;;;;;;;:::i;:::-;;;;:20;;;:32;;;;:::i;:::-;:56;;65600:119;;;::::0;::::1;::::0;;17789:2:1;65600:119:0::1;::::0;::::1;17771:21:1::0;17828:2;17808:18;;;17801:30;17867:15;17847:18;;;17840:43;17900:18;;65600:119:0::1;17587:337:1::0;65600:119:0::1;65737:9;65732:200;65756:9;65752:1;:13;65732:200;;;65787:15;65805:6;65812:7;65805:15;;;;;;;:::i;:::-;;;;:20;;;:22;;;;;;;;;:::i;:::-;;;;;65787:40;;65842:28;65852:8;65862:7;65842:9;:28::i;:::-;65885:17;::::0;;;:8:::1;:17;::::0;;;;65905:15:::1;65885:35:::0;;65767:3;::::1;::::0;::::1;:::i;:::-;;;;65732:200;;;-1:-1:-1::0;;57248:1:0;58202:7;:22;-1:-1:-1;;65396:543:0:o;71317:476::-;71582:53;;;71550:17;20977:55:1;;;71582:53:0;;;20959:74:1;21049:18;;;;21042:34;;;71582:53:0;;;;;;;;;;20932:18:1;;;;71582:53:0;;;;;;;;;;;;;71550:96;;-1:-1:-1;;;;71550:17:0;;;;:96;;71582:53;71550:96;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71514:132;;;;71679:7;:57;;;;-1:-1:-1;71691:11:0;;:16;;:44;;;71722:4;71711:24;;;;;;;;;;;;:::i;:::-;71657:128;;;;;;;21568:2:1;71657:128:0;;;21550:21:1;21607:2;21587:18;;;21580:30;21646:23;21626:18;;;21619:51;21687:18;;71657:128:0;21366:345:1;40611:348:0;40704:4;40406:16;;;:7;:16;;;;;;:30;:16;40721:73;;;;;;;21918:2:1;40721:73:0;;;21900:21:1;21957:2;21937:18;;;21930:30;21996:34;21976:18;;;21969:62;22067:14;22047:18;;;22040:42;22099:19;;40721:73:0;21716:408:1;40721:73:0;40805:13;40821:23;40836:7;40821:14;:23::i;:::-;40805:39;;40874:5;40863:16;;:7;:16;;;:51;;;;40907:7;40883:31;;:20;40895:7;40883:11;:20::i;:::-;:31;;;40863:51;:87;;;-1:-1:-1;37703:25:0;;;;37679:4;37703:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;40918:32;40855:96;40611:348;-1:-1:-1;;;;40611:348:0:o;43603:578::-;43762:4;43735:31;;:23;43750:7;43735:14;:23::i;:::-;:31;;;43727:85;;;;;;;22331:2:1;43727:85:0;;;22313:21:1;22370:2;22350:18;;;22343:30;22409:34;22389:18;;;22382:62;22480:11;22460:18;;;22453:39;22509:19;;43727:85:0;22129:405:1;43727:85:0;43831:16;;;43823:65;;;;;;;22741:2:1;43823:65:0;;;22723:21:1;22780:2;22760:18;;;22753:30;22819:34;22799:18;;;22792:62;22890:6;22870:18;;;22863:34;22914:19;;43823:65:0;22539:400:1;43823:65:0;43901:39;43922:4;43928:2;43932:7;43901:20;:39::i;:::-;44005:29;44022:1;44026:7;44005:8;:29::i;:::-;44047:15;;;;;;;:9;:15;;;;;:20;;44066:1;;44047:15;:20;;44066:1;;44047:20;:::i;:::-;;;;-1:-1:-1;;44078:13:0;;;;;;;:9;:13;;;;;:18;;44095:1;;44078:13;:18;;44095:1;;44078:18;:::i;:::-;;;;-1:-1:-1;;44107:16:0;;;;:7;:16;;;;;;:21;;;;;;;;;;;;;;44146:27;;44107:16;;44146:27;;;;;;;43603:578;;;:::o;60641:191::-;60734:6;;;;60751:17;;;;;;;;;;;60784:40;;60734:6;;;60751:17;60734:6;;60784:40;;60715:16;;60784:40;60704:128;60641:191;:::o;44615:315::-;44770:8;44761:17;;:5;:17;;;;44753:55;;;;;;;23276:2:1;44753:55:0;;;23258:21:1;23315:2;23295:18;;;23288:30;23354:27;23334:18;;;23327:55;23399:18;;44753:55:0;23074:349:1;44753:55:0;44819:25;;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;;;;;;;;;;;;44881:41;;586::1;;;44881::0;;559:18:1;44881:41:0;;;;;;;44615:315;;;:::o;39689:::-;39846:28;39856:4;39862:2;39866:7;39846:9;:28::i;:::-;39893:48;39916:4;39922:2;39926:7;39935:5;39893:22;:48::i;:::-;39885:111;;;;;;;23630:2:1;39885:111:0;;;23612:21:1;23669:2;23649:18;;;23642:30;23708:34;23688:18;;;23681:62;23779:20;23759:18;;;23752:48;23817:19;;39885:111:0;23428:414:1;410:723:0;466:13;687:10;683:53;;-1:-1:-1;;714:10:0;;;;;;;;;;;;;;;;;;410:723::o;683:53::-;761:5;746:12;802:78;809:9;;802:78;;835:8;;;;:::i;:::-;;-1:-1:-1;858:10:0;;-1:-1:-1;866:2:0;858:10;;:::i;:::-;;;802:78;;;890:19;922:6;912:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;912:17:0;;890:39;;940:154;947:10;;940:154;;974:11;984:1;974:11;;:::i;:::-;;-1:-1:-1;1043:10:0;1051:2;1043:5;:10;:::i;:::-;1030:24;;:2;:24;:::i;:::-;1017:39;;1000:6;1007;1000:14;;;;;;;;:::i;:::-;;;;:56;;;;;;;;;;-1:-1:-1;1071:11:0;1080:2;1071:11;;:::i;:::-;;;940:154;;6641:231;6719:7;6740:17;6759:18;6781:27;6792:4;6798:9;6781:10;:27::i;:::-;6739:69;;;;6819:18;6831:5;6819:11;:18::i;71127:182::-;71200:12;71218:9;:14;;71240:6;71218:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71199:52;;;71270:7;71262:39;;;;;;;24690:2:1;71262:39:0;;;24672:21:1;24729:2;24709:18;;;24702:30;24768:21;24748:18;;;24741:49;24807:18;;71262:39:0;24488:343:1;34559:305:0;34661:4;34698:40;;;34713:25;34698:40;;:105;;-1:-1:-1;34755:48:0;;;34770:33;34755:48;34698:105;:158;;;-1:-1:-1;32672:25:0;32657:40;;;;34820:36;32548:157;41301:110;41377:26;41387:2;41391:7;41377:26;;;;;;;;;;;;:9;:26::i;67102:215::-;67264:45;67291:4;67297:2;67301:7;67264:26;:45::i;45495:799::-;45650:4;45671:13;;;23684:20;23732:8;45667:620;;45707:72;;;;;:36;;;;;;:72;;31465:10;;45758:4;;45764:7;;45773:5;;45707:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;45707:72:0;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;45703:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;45949:13:0;;45945:272;;45992:60;;;;;23630:2:1;45992:60:0;;;23612:21:1;23669:2;23649:18;;;23642:30;23708:34;23688:18;;;23681:62;23779:20;23759:18;;;23752:48;23817:19;;45992:60:0;23428:414:1;45945:272:0;46167:6;46161:13;46152:6;46148:2;46144:15;46137:38;45703:529;45830:51;;45840:41;45830:51;;-1:-1:-1;45823:58:0;;45667:620;-1:-1:-1;46271:4:0;45495:799;;;;;;:::o;4531:1308::-;4612:7;4621:12;4846:9;:16;4866:2;4846:22;4842:990;;;5142:4;5127:20;;5121:27;5192:4;5177:20;;5171:27;5250:4;5235:20;;5229:27;4885:9;5221:36;5293:25;5304:4;5221:36;5121:27;5171;5293:10;:25::i;:::-;5286:32;;;;;;;;;4842:990;5340:9;:16;5360:2;5340:22;5336:496;;;5615:4;5600:20;;5594:27;5666:4;5651:20;;5645:27;5708:23;5719:4;5594:27;5645;5708:10;:23::i;:::-;5701:30;;;;;;;;5336:496;-1:-1:-1;5780:1:0;;-1:-1:-1;5784:35:0;5336:496;4531:1308;;;;;:::o;2802:643::-;2880:20;2871:5;:29;;;;;;;;:::i;:::-;;2867:571;;;2802:643;:::o;2867:571::-;2978:29;2969:5;:38;;;;;;;;:::i;:::-;;2965:473;;;3024:34;;;;;25998:2:1;3024:34:0;;;25980:21:1;26037:2;26017:18;;;26010:30;26076:26;26056:18;;;26049:54;26120:18;;3024:34:0;25796:348:1;2965:473:0;3089:35;3080:5;:44;;;;;;;;:::i;:::-;;3076:362;;;3141:41;;;;;26351:2:1;3141:41:0;;;26333:21:1;26390:2;26370:18;;;26363:30;26429:33;26409:18;;;26402:61;26480:18;;3141:41:0;26149:355:1;3076:362:0;3213:30;3204:5;:39;;;;;;;;:::i;:::-;;3200:238;;;3260:44;;;;;26711:2:1;3260:44:0;;;26693:21:1;26750:2;26730:18;;;26723:30;26789:34;26769:18;;;26762:62;26860:4;26840:18;;;26833:32;26882:19;;3260:44:0;26509:398:1;3200:238:0;3335:30;3326:5;:39;;;;;;;;:::i;:::-;;3322:116;;;3382:44;;;;;27114:2:1;3382:44:0;;;27096:21:1;27153:2;27133:18;;;27126:30;27192:34;27172:18;;;27165:62;27263:4;27243:18;;;27236:32;27285:19;;3382:44:0;26912:398:1;41638:321:0;41768:18;41774:2;41778:7;41768:5;:18::i;:::-;41819:54;41850:1;41854:2;41858:7;41867:5;41819:22;:54::i;:::-;41797:154;;;;;;;23630:2:1;41797:154:0;;;23612:21:1;23669:2;23649:18;;;23642:30;23708:34;23688:18;;;23681:62;23779:20;23759:18;;;23752:48;23817:19;;41797:154:0;23428:414:1;50994:589:0;51200:18;;;51196:187;;51235:40;51267:7;52410:10;:17;;52383:24;;;;:15;:24;;;;;:44;;;52438:24;;;;;;;;;;;;52306:164;51235:40;51196:187;;;51305:2;51297:10;;:4;:10;;;51293:90;;51324:47;51357:4;51363:7;51324:32;:47::i;:::-;51397:16;;;51393:183;;51430:45;51467:7;51430:36;:45::i;51393:183::-;51503:4;51497:10;;:2;:10;;;51493:83;;51524:40;51552:2;51556:7;51524:27;:40::i;8140:1632::-;8271:7;;9205:66;9192:79;;9188:163;;;-1:-1:-1;9304:1:0;;-1:-1:-1;9308:30:0;9288:51;;9188:163;9365:1;:7;;9370:2;9365:7;;:18;;;;;9376:1;:7;;9381:2;9376:7;;9365:18;9361:102;;;-1:-1:-1;9416:1:0;;-1:-1:-1;9420:30:0;9400:51;;9361:102;9577:24;;;9560:14;9577:24;;;;;;;;;27542:25:1;;;27615:4;27603:17;;27583:18;;;27576:45;;;;27637:18;;;27630:34;;;27680:18;;;27673:34;;;9577:24:0;;27514:19:1;;9577:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;9577:24:0;;;;;;-1:-1:-1;;9616:20:0;;;9612:103;;9669:1;9673:29;9653:50;;;;;;;9612:103;9735:6;-1:-1:-1;9743:20:0;;-1:-1:-1;8140:1632:0;;;;;;;;:::o;7135:391::-;7249:7;;7358:66;7350:75;;7452:3;7448:12;;;7462:2;7444:21;7493:25;7504:4;7444:21;7513:1;7350:75;7493:10;:25::i;:::-;7486:32;;;;;;7135:391;;;;;;:::o;42295:382::-;42375:16;;;42367:61;;;;;;;27920:2:1;42367:61:0;;;27902:21:1;;;27939:18;;;27932:30;27998:34;27978:18;;;27971:62;28050:18;;42367:61:0;27718:356:1;42367:61:0;40382:4;40406:16;;;:7;:16;;;;;;:30;:16;:30;42439:58;;;;;;;28281:2:1;42439:58:0;;;28263:21:1;28320:2;28300:18;;;28293:30;28359;28339:18;;;28332:58;28407:18;;42439:58:0;28079:352:1;42439:58:0;42510:45;42539:1;42543:2;42547:7;42510:20;:45::i;:::-;42568:13;;;;;;;:9;:13;;;;;:18;;42585:1;;42568:13;:18;;42585:1;;42568:18;:::i;:::-;;;;-1:-1:-1;;42597:16:0;;;;:7;:16;;;;;;:21;;;;;;;;;;;;;42636:33;;42597:16;;;42636:33;;42597:16;;42636:33;42295:382;;:::o;53097:988::-;53363:22;53413:1;53388:22;53405:4;53388:16;:22::i;:::-;:26;;;;:::i;:::-;53425:18;53446:26;;;:17;:26;;;;;;53363:51;;-1:-1:-1;53579:28:0;;;53575:328;;53646:18;;;53624:19;53646:18;;;:12;:18;;;;;;;;:34;;;;;;;;;53697:30;;;;;;:44;;;53814:30;;:17;:30;;;;;:43;;;53575:328;-1:-1:-1;53999:26:0;;;;:17;:26;;;;;;;;53992:33;;;54043:18;;;;;;:12;:18;;;;;:34;;;;;;;54036:41;53097:988::o;54380:1079::-;54658:10;:17;54633:22;;54658:21;;54678:1;;54658:21;:::i;:::-;54690:18;54711:24;;;:15;:24;;;;;;55084:10;:26;;54633:46;;-1:-1:-1;54711:24:0;;54633:46;;55084:26;;;;;;:::i;:::-;;;;;;;;;55062:48;;55148:11;55123:10;55134;55123:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;55228:28;;;:15;:28;;;;;;;:41;;;55400:24;;;;;55393:31;55435:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;54451:1008;;;54380:1079;:::o;51884:221::-;51969:14;51986:20;52003:2;51986:16;:20::i;:::-;52017:16;;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;52062:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;51884:221:0:o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:177:1;99:66;92:5;88:78;81:5;78:89;68:117;;181:1;178;171:12;196:245;254:6;307:2;295:9;286:7;282:23;278:32;275:52;;;323:1;320;313:12;275:52;362:9;349:23;381:30;405:5;381:30;:::i;:::-;430:5;196:245;-1:-1:-1;;;196:245:1:o;638:196::-;706:20;;766:42;755:54;;745:65;;735:93;;824:1;821;814:12;735:93;638:196;;;:::o;839:184::-;891:77;888:1;881:88;988:4;985:1;978:15;1012:4;1009:1;1002:15;1028:334;1099:2;1093:9;1155:2;1145:13;;1160:66;1141:86;1129:99;;1258:18;1243:34;;1279:22;;;1240:62;1237:88;;;1305:18;;:::i;:::-;1341:2;1334:22;1028:334;;-1:-1:-1;1028:334:1:o;1367:465::-;1431:5;1465:18;1457:6;1454:30;1451:56;;;1487:18;;:::i;:::-;1525:116;1635:4;1566:66;1561:2;1553:6;1549:15;1545:88;1541:99;1525:116;:::i;:::-;1516:125;;1664:6;1657:5;1650:21;1704:3;1695:6;1690:3;1686:16;1683:25;1680:45;;;1721:1;1718;1711:12;1680:45;1770:6;1765:3;1758:4;1751:5;1747:16;1734:43;1824:1;1817:4;1808:6;1801:5;1797:18;1793:29;1786:40;1367:465;;;;;:::o;1837:220::-;1879:5;1932:3;1925:4;1917:6;1913:17;1909:27;1899:55;;1950:1;1947;1940:12;1899:55;1972:79;2047:3;2038:6;2025:20;2018:4;2010:6;2006:17;1972:79;:::i;2062:669::-;2175:6;2183;2191;2199;2207;2215;2268:3;2256:9;2247:7;2243:23;2239:33;2236:53;;;2285:1;2282;2275:12;2236:53;2321:9;2308:23;2298:33;;2378:2;2367:9;2363:18;2350:32;2340:42;;2401:38;2435:2;2424:9;2420:18;2401:38;:::i;:::-;2391:48;;2486:2;2475:9;2471:18;2458:32;2448:42;;2537:3;2526:9;2522:19;2509:33;2499:43;;2593:3;2582:9;2578:19;2565:33;2621:18;2613:6;2610:30;2607:50;;;2653:1;2650;2643:12;2607:50;2676:49;2717:7;2708:6;2697:9;2693:22;2676:49;:::i;:::-;2666:59;;;2062:669;;;;;;;;:::o;2736:258::-;2808:1;2818:113;2832:6;2829:1;2826:13;2818:113;;;2908:11;;;2902:18;2889:11;;;2882:39;2854:2;2847:10;2818:113;;;2949:6;2946:1;2943:13;2940:48;;;-1:-1:-1;;2984:1:1;2966:16;;2959:27;2736:258::o;2999:317::-;3041:3;3079:5;3073:12;3106:6;3101:3;3094:19;3122:63;3178:6;3171:4;3166:3;3162:14;3155:4;3148:5;3144:16;3122:63;:::i;:::-;3230:2;3218:15;3235:66;3214:88;3205:98;;;;3305:4;3201:109;;2999:317;-1:-1:-1;;2999:317:1:o;3321:220::-;3470:2;3459:9;3452:21;3433:4;3490:45;3531:2;3520:9;3516:18;3508:6;3490:45;:::i;3546:180::-;3605:6;3658:2;3646:9;3637:7;3633:23;3629:32;3626:52;;;3674:1;3671;3664:12;3626:52;-1:-1:-1;3697:23:1;;3546:180;-1:-1:-1;3546:180:1:o;3962:254::-;4030:6;4038;4091:2;4079:9;4070:7;4066:23;4062:32;4059:52;;;4107:1;4104;4097:12;4059:52;4130:29;4149:9;4130:29;:::i;:::-;4120:39;4206:2;4191:18;;;;4178:32;;-1:-1:-1;;;3962:254:1:o;4221:1020::-;4314:6;4322;4375:2;4363:9;4354:7;4350:23;4346:32;4343:52;;;4391:1;4388;4381:12;4343:52;4427:9;4414:23;4404:33;;4456:2;4509;4498:9;4494:18;4481:32;4532:18;4573:2;4565:6;4562:14;4559:34;;;4589:1;4586;4579:12;4559:34;4627:6;4616:9;4612:22;4602:32;;4672:7;4665:4;4661:2;4657:13;4653:27;4643:55;;4694:1;4691;4684:12;4643:55;4730:2;4717:16;4752:2;4748;4745:10;4742:36;;;4758:18;;:::i;:::-;4804:2;4801:1;4797:10;4787:20;;4827:28;4851:2;4847;4843:11;4827:28;:::i;:::-;4889:15;;;4959:11;;;4955:20;;;4920:12;;;;4987:19;;;4984:39;;;5019:1;5016;5009:12;4984:39;5043:11;;;;5063:148;5079:6;5074:3;5071:15;5063:148;;;5145:23;5164:3;5145:23;:::i;:::-;5133:36;;5096:12;;;;5189;;;;5063:148;;;5230:5;5220:15;;;;;;;;4221:1020;;;;;:::o;5246:328::-;5323:6;5331;5339;5392:2;5380:9;5371:7;5367:23;5363:32;5360:52;;;5408:1;5405;5398:12;5360:52;5431:29;5450:9;5431:29;:::i;:::-;5421:39;;5479:38;5513:2;5502:9;5498:18;5479:38;:::i;:::-;5469:48;;5564:2;5553:9;5549:18;5536:32;5526:42;;5246:328;;;;;:::o;5761:186::-;5820:6;5873:2;5861:9;5852:7;5848:23;5844:32;5841:52;;;5889:1;5886;5879:12;5841:52;5912:29;5931:9;5912:29;:::i;5952:450::-;6021:6;6074:2;6062:9;6053:7;6049:23;6045:32;6042:52;;;6090:1;6087;6080:12;6042:52;6130:9;6117:23;6163:18;6155:6;6152:30;6149:50;;;6195:1;6192;6185:12;6149:50;6218:22;;6271:4;6263:13;;6259:27;-1:-1:-1;6249:55:1;;6300:1;6297;6290:12;6249:55;6323:73;6388:7;6383:2;6370:16;6365:2;6361;6357:11;6323:73;:::i;6407:632::-;6578:2;6630:21;;;6700:13;;6603:18;;;6722:22;;;6549:4;;6578:2;6801:15;;;;6775:2;6760:18;;;6549:4;6844:169;6858:6;6855:1;6852:13;6844:169;;;6919:13;;6907:26;;6988:15;;;;6953:12;;;;6880:1;6873:9;6844:169;;;-1:-1:-1;7030:3:1;;6407:632;-1:-1:-1;;;;;;6407:632:1:o;7044:118::-;7130:5;7123:13;7116:21;7109:5;7106:32;7096:60;;7152:1;7149;7142:12;7167:315;7232:6;7240;7293:2;7281:9;7272:7;7268:23;7264:32;7261:52;;;7309:1;7306;7299:12;7261:52;7332:29;7351:9;7332:29;:::i;:::-;7322:39;;7411:2;7400:9;7396:18;7383:32;7424:28;7446:5;7424:28;:::i;:::-;7471:5;7461:15;;;7167:315;;;;;:::o;7487:248::-;7555:6;7563;7616:2;7604:9;7595:7;7591:23;7587:32;7584:52;;;7632:1;7629;7622:12;7584:52;-1:-1:-1;;7655:23:1;;;7725:2;7710:18;;;7697:32;;-1:-1:-1;7487:248:1:o;7740:537::-;7835:6;7843;7851;7859;7912:3;7900:9;7891:7;7887:23;7883:33;7880:53;;;7929:1;7926;7919:12;7880:53;7952:29;7971:9;7952:29;:::i;:::-;7942:39;;8000:38;8034:2;8023:9;8019:18;8000:38;:::i;:::-;7990:48;;8085:2;8074:9;8070:18;8057:32;8047:42;;8140:2;8129:9;8125:18;8112:32;8167:18;8159:6;8156:30;8153:50;;;8199:1;8196;8189:12;8153:50;8222:49;8263:7;8254:6;8243:9;8239:22;8222:49;:::i;:::-;8212:59;;;7740:537;;;;;;;:::o;8282:744::-;8404:6;8412;8420;8428;8436;8444;8452;8505:3;8493:9;8484:7;8480:23;8476:33;8473:53;;;8522:1;8519;8512:12;8473:53;8545:29;8564:9;8545:29;:::i;:::-;8535:39;;8621:2;8610:9;8606:18;8593:32;8583:42;;8672:2;8661:9;8657:18;8644:32;8634:42;;8695:38;8729:2;8718:9;8714:18;8695:38;:::i;:::-;8685:48;;8780:3;8769:9;8765:19;8752:33;8742:43;;8832:3;8821:9;8817:19;8804:33;8794:43;;8888:3;8877:9;8873:19;8860:33;8916:18;8908:6;8905:30;8902:50;;;8948:1;8945;8938:12;8902:50;8971:49;9012:7;9003:6;8992:9;8988:22;8971:49;:::i;:::-;8961:59;;;8282:744;;;;;;;;;;:::o;9437:260::-;9505:6;9513;9566:2;9554:9;9545:7;9541:23;9537:32;9534:52;;;9582:1;9579;9572:12;9534:52;9605:29;9624:9;9605:29;:::i;:::-;9595:39;;9653:38;9687:2;9676:9;9672:18;9653:38;:::i;:::-;9643:48;;9437:260;;;;;:::o;9702:184::-;9754:77;9751:1;9744:88;9851:4;9848:1;9841:15;9875:4;9872:1;9865:15;9891:128;9931:3;9962:1;9958:6;9955:1;9952:13;9949:39;;;9968:18;;:::i;:::-;-1:-1:-1;10004:9:1;;9891:128::o;10024:437::-;10103:1;10099:12;;;;10146;;;10167:61;;10221:4;10213:6;10209:17;10199:27;;10167:61;10274:2;10266:6;10263:14;10243:18;10240:38;10237:218;;;10311:77;10308:1;10301:88;10412:4;10409:1;10402:15;10440:4;10437:1;10430:15;12058:184;12110:77;12107:1;12100:88;12207:4;12204:1;12197:15;12231:4;12228:1;12221:15;12247:195;12286:3;12317:66;12310:5;12307:77;12304:103;;;12387:18;;:::i;:::-;-1:-1:-1;12434:1:1;12423:13;;12247:195::o;15414:1088::-;15499:12;;15464:3;;15554:1;15574:18;;;;15627;;;;15654:61;;15708:4;15700:6;15696:17;15686:27;;15654:61;15734:2;15782;15774:6;15771:14;15751:18;15748:38;15745:218;;;15819:77;15816:1;15809:88;15920:4;15917:1;15910:15;15948:4;15945:1;15938:15;15745:218;15979:18;16006:162;;;;16182:1;16177:319;;;;15972:524;;16006:162;16054:66;16043:9;16039:82;16034:3;16027:95;16151:6;16146:3;16142:16;16135:23;;16006:162;;16177:319;15361:1;15354:14;;;15398:4;15385:18;;16271:1;16285:165;16299:6;16296:1;16293:13;16285:165;;;16377:14;;16364:11;;;16357:35;16420:16;;;;16314:10;;16285:165;;;16289:3;;16479:6;16474:3;16470:16;16463:23;;15972:524;;;;;;;15414:1088;;;;:::o;16507:456::-;16728:3;16756:38;16790:3;16782:6;16756:38;:::i;:::-;16823:6;16817:13;16839:52;16884:6;16880:2;16873:4;16865:6;16861:17;16839:52;:::i;:::-;16907:50;16949:6;16945:2;16941:15;16933:6;16907:50;:::i;:::-;16900:57;16507:456;-1:-1:-1;;;;;;;16507:456:1:o;19494:245::-;19561:6;19614:2;19602:9;19593:7;19589:23;19585:32;19582:52;;;19630:1;19627;19620:12;19582:52;19662:9;19656:16;19681:28;19703:5;19681:28;:::i;21087:274::-;21216:3;21254:6;21248:13;21270:53;21316:6;21311:3;21304:4;21296:6;21292:17;21270:53;:::i;:::-;21339:16;;;;;21087:274;-1:-1:-1;;21087:274:1:o;22944:125::-;22984:4;23012:1;23009;23006:8;23003:34;;;23017:18;;:::i;:::-;-1:-1:-1;23054:9:1;;22944:125::o;23847:184::-;23899:77;23896:1;23889:88;23996:4;23993:1;23986:15;24020:4;24017:1;24010:15;24036:120;24076:1;24102;24092:35;;24107:18;;:::i;:::-;-1:-1:-1;24141:9:1;;24036:120::o;24161:112::-;24193:1;24219;24209:35;;24224:18;;:::i;:::-;-1:-1:-1;24258:9:1;;24161:112::o;24836:512::-;25030:4;25059:42;25140:2;25132:6;25128:15;25117:9;25110:34;25192:2;25184:6;25180:15;25175:2;25164:9;25160:18;25153:43;;25232:6;25227:2;25216:9;25212:18;25205:34;25275:3;25270:2;25259:9;25255:18;25248:31;25296:46;25337:3;25326:9;25322:19;25314:6;25296:46;:::i;:::-;25288:54;24836:512;-1:-1:-1;;;;;;24836:512:1:o;25353:249::-;25422:6;25475:2;25463:9;25454:7;25450:23;25446:32;25443:52;;;25491:1;25488;25481:12;25443:52;25523:9;25517:16;25542:30;25566:5;25542:30;:::i;25607:184::-;25659:77;25656:1;25649:88;25756:4;25753:1;25746:15;25780:4;25777:1;25770:15;28436:184;28488:77;28485:1;28478:88;28585:4;28582:1;28575:15;28609:4;28606:1;28599:15

ipfs://b13963a407986e67540720be8b879fb4804ea06e1abb5e8d11cb37f5fdd5ca5d