Contract 0xc427e0b2e4c9b79f856391b1ef37fd7ee7457d8d

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

// Sources flattened with hardhat v2.8.3 https://hardhat.org

// File @openzeppelin/contracts/utils/[email protected]


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

pragma solidity ^0.8.0;

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

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


// File @openzeppelin/contracts/access/[email protected]


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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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


// File @openzeppelin/contracts/utils/introspection/[email protected]


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


// File @openzeppelin/contracts/token/ERC721/[email protected]


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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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


// File @openzeppelin/contracts/token/ERC721/[email protected]


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


// File @openzeppelin/contracts/token/ERC721/extensions/[email protected]


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

pragma solidity ^0.8.0;

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

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

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


// File @openzeppelin/contracts/utils/[email protected]


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


// File @openzeppelin/contracts/utils/[email protected]


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


// File @openzeppelin/contracts/utils/introspection/[email protected]


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

pragma solidity ^0.8.0;

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


// File @openzeppelin/contracts/token/ERC721/[email protected]


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

pragma solidity ^0.8.0;







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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

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

        _transfer(from, to, tokenId);
    }

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

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

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _beforeTokenTransfer(from, to, tokenId);

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

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

        emit Transfer(from, to, tokenId);
    }

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

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

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

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


// File @openzeppelin/contracts/token/ERC721/extensions/[email protected]


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

pragma solidity ^0.8.0;

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


// File @openzeppelin/contracts/token/ERC721/extensions/[email protected]


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

pragma solidity ^0.8.0;


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


// File @openzeppelin/contracts/token/ERC1155/[email protected]


// OpenZeppelin Contracts v4.4.1 (token/ERC1155/IERC1155.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must be have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes calldata data
    ) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) external;
}


// File @openzeppelin/contracts/utils/escrow/[email protected]


// OpenZeppelin Contracts v4.4.1 (utils/escrow/Escrow.sol)

pragma solidity ^0.8.0;


/**
 * @title Escrow
 * @dev Base escrow contract, holds funds designated for a payee until they
 * withdraw them.
 *
 * Intended usage: This contract (and derived escrow contracts) should be a
 * standalone contract, that only interacts with the contract that instantiated
 * it. That way, it is guaranteed that all Ether will be handled according to
 * the `Escrow` rules, and there is no need to check for payable functions or
 * transfers in the inheritance tree. The contract that uses the escrow as its
 * payment method should be its owner, and provide public methods redirecting
 * to the escrow's deposit and withdraw.
 */
contract Escrow is Ownable {
    using Address for address payable;

    event Deposited(address indexed payee, uint256 weiAmount);
    event Withdrawn(address indexed payee, uint256 weiAmount);

    mapping(address => uint256) private _deposits;

    function depositsOf(address payee) public view returns (uint256) {
        return _deposits[payee];
    }

    /**
     * @dev Stores the sent amount as credit to be withdrawn.
     * @param payee The destination address of the funds.
     */
    function deposit(address payee) public payable virtual onlyOwner {
        uint256 amount = msg.value;
        _deposits[payee] += amount;
        emit Deposited(payee, amount);
    }

    /**
     * @dev Withdraw accumulated balance for a payee, forwarding all gas to the
     * recipient.
     *
     * WARNING: Forwarding all gas opens the door to reentrancy vulnerabilities.
     * Make sure you trust the recipient, or are either following the
     * checks-effects-interactions pattern or using {ReentrancyGuard}.
     *
     * @param payee The address whose funds will be withdrawn and transferred to.
     */
    function withdraw(address payable payee) public virtual onlyOwner {
        uint256 payment = _deposits[payee];

        _deposits[payee] = 0;

        payee.sendValue(payment);

        emit Withdrawn(payee, payment);
    }
}


// File @openzeppelin/contracts/security/[email protected]


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

pragma solidity ^0.8.0;

/**
 * @dev Simple implementation of a
 * https://consensys.github.io/smart-contract-best-practices/recommendations/#favor-pull-over-push-for-external-calls[pull-payment]
 * strategy, where the paying contract doesn't interact directly with the
 * receiver account, which must withdraw its payments itself.
 *
 * Pull-payments are often considered the best practice when it comes to sending
 * Ether, security-wise. It prevents recipients from blocking execution, and
 * eliminates reentrancy concerns.
 *
 * 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].
 *
 * To use, derive from the `PullPayment` contract, and use {_asyncTransfer}
 * instead of Solidity's `transfer` function. Payees can query their due
 * payments with {payments}, and retrieve them with {withdrawPayments}.
 */
abstract contract PullPayment {
    Escrow private immutable _escrow;

    constructor() {
        _escrow = new Escrow();
    }

    /**
     * @dev Withdraw accumulated payments, forwarding all gas to the recipient.
     *
     * Note that _any_ account can call this function, not just the `payee`.
     * This means that contracts unaware of the `PullPayment` protocol can still
     * receive funds this way, by having a separate account call
     * {withdrawPayments}.
     *
     * WARNING: Forwarding all gas opens the door to reentrancy vulnerabilities.
     * Make sure you trust the recipient, or are either following the
     * checks-effects-interactions pattern or using {ReentrancyGuard}.
     *
     * @param payee Whose payments will be withdrawn.
     */
    function withdrawPayments(address payable payee) public virtual {
        _escrow.withdraw(payee);
    }

    /**
     * @dev Returns the payments owed to an address.
     * @param dest The creditor's address.
     */
    function payments(address dest) public view returns (uint256) {
        return _escrow.depositsOf(dest);
    }

    /**
     * @dev Called by the payer to store the sent amount as credit to be pulled.
     * Funds sent in this way are stored in an intermediate {Escrow} contract, so
     * there is no danger of them being spent before withdrawal.
     *
     * @param dest The destination address of the funds.
     * @param amount The amount to transfer.
     */
    function _asyncTransfer(address dest, uint256 amount) internal virtual {
        _escrow.deposit{value: amount}(dest);
    }
}


// File contracts/MarbleNFT.sol

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IMarketplace {
    struct Info {
        uint256 regularCost;
        uint256 memberCost;
        uint256 whitelistCost;
        uint256 maxSupply;
        uint256 totalSupply;
        uint256 maxMintPerAddress;
        uint256 maxMintPerTx;
    }

    function mintCost(address _minter) external view returns (uint256);

    function canMint(address _minter) external view returns (uint256);

    function mint(uint256 _amount) external payable;

    function maxSupply() external view returns (uint256);

    function getInfo() external view returns (Info memory);
}

interface IMemberships {
    function isMember(address _minter) external view returns (bool);
}

struct TokenData {
    uint256 id;
    mapping(uint256 => uint256) upgrades;
}

contract MarbleNFT is ERC721Enumerable, Ownable, IMarketplace, PullPayment {
    uint256 constant MAX_MINT = 20000;
    uint256 constant PRICE_INCREASE_INTERVAL = 2000;
    uint256 constant INITIAL_PRICE = 80;
    uint256 constant PRICE_INCREASE = 10;
    uint256 constant MAX_MINT_PER_TRANSACTION = 10;
    address constant MEMBERSHIP_ADDRESS = 0x7a3CdB2364f92369a602CAE81167d0679087e6a3;
    address constant MARKET_SHARE_ADDRESS = 0x454cfAa623A629CC0b4017aEb85d54C42e91479d;
    address constant OWNER_ADDRESS = 0x5937Bb1A9247ed70A61B669B55B2e3b7471e7330;

    mapping(uint256 => TokenData) public tokenIdToTokenData;
    mapping(address => bool) public whitelist;
    mapping(address => uint256) public minters;
    address marbleManager;
    IMemberships memberships;

    string public baseURI;
    bool mintEnabled;
    bool whitelistOnly;

    /////////////////////
    //    MODIFIERS    //
    /////////////////////

    modifier onlyMintEnabled() {
        require(mintEnabled, "Mint Disabled");
        _;
    }

    modifier onlyWhitelisted() {
        if (whitelistOnly) {
            require(isWhitelisted(msg.sender), "Not Whitelisted");
        }
        _;
    }

    modifier onlyMarbleManager() {
        require(msg.sender == marbleManager, "No Permission");
        _;
    }

    /////////////////////
    //    MarbleNFT    //
    /////////////////////

    constructor() ERC721("Marble", "MRBL") {
        memberships = IMemberships(MEMBERSHIP_ADDRESS);
        baseURI = "ipfs://QmUQiJb9SGgyor3r7aGGKLV2bhr36BhoSB1wSsX9MCHcvp/";
        mintEnabled = false;
        whitelistOnly = true;

        //Transfer contract to developers account
        transferOwnership(OWNER_ADDRESS);
    }

    //Calculates Mint Cost
    function calculateMintCost(uint256 currentSupply) public pure returns (uint256) {
        uint256 increment = currentSupply / PRICE_INCREASE_INTERVAL;
        uint256 croValue = INITIAL_PRICE + PRICE_INCREASE * increment;
        return croValue * (10**18);
    }

    //Calculating Current Mint Cost
    function calculateCurrentMintCost() public view returns (uint256) {
        return calculateMintCost(totalSupply());
    }

    //Update Base URL
    function updateBaseURI(string memory _newURI) external onlyOwner {
        baseURI = _newURI;
    }

    //Update Mintable
    function setMintEnabled(bool _mintEnabled) external onlyOwner {
        mintEnabled = _mintEnabled;
    }

    //Update Whitelist Only
    function setWhitelistOnly(bool _whitelistOnly) external onlyOwner {
        whitelistOnly = _whitelistOnly;
    }

    //Mint with Native Token From Marketplace
    function mint(uint256 _amount) external payable override onlyMintEnabled onlyWhitelisted {
        mintPrivate(_amount);

        uint256 marketShare = (msg.value * 10) / 100;
        uint256 ownerShare = msg.value - marketShare;
        _asyncTransfer(MARKET_SHARE_ADDRESS, marketShare);
        _asyncTransfer(owner(), ownerShare);
    }

    //Mint with Native Token
    function mintMarble(uint256 _amount) external payable onlyMintEnabled onlyWhitelisted {
        mintPrivate(_amount);

        _asyncTransfer(owner(), msg.value);
    }

    //Private Mint Function
    function mintPrivate(uint256 _amount) private {
        require(_amount <= MAX_MINT_PER_TRANSACTION, "Invalid mint amount");
        require(_amount > 0, "Invalid mint amount");
        require(totalSupply() + _amount <= MAX_MINT, "Exceeding Max Mint Count");

        uint256 requiredAmount = mintCost(msg.sender) * _amount;
        require(requiredAmount == msg.value, "Incorrect Payment");

        for (uint256 i = 0; i < _amount; i++) {
            uint256 index = totalSupply() + 1;
            _safeMint(msg.sender, index);
            TokenData storage newToken = tokenIdToTokenData[index];
            newToken.id = index;
        }

        minters[msg.sender] += _amount;
    }

    //Add Whitelist
    function addWhitelist(address[] calldata _addresses) external onlyOwner {
        for (uint256 index = 0; index < _addresses.length; index++) {
            whitelist[_addresses[index]] = true;
        }
    }

    //Remove Whitelist
    function removeWhitelist(address[] calldata _addresses) external onlyOwner {
        for (uint256 index = 0; index < _addresses.length; index++) {
            whitelist[_addresses[index]] = false;
        }
    }

    //////////////////////////
    //    MARBLE MANAGER    //
    //////////////////////////

    //Let MarbleManager deal with Marble Upgrades
    function updateMarbleUpgrade(
        uint256 marbleID,
        uint256 upgradeID,
        uint256 upgradeLevel
    ) external onlyMarbleManager {
        require(_exists(marbleID), "Marble does not exist");
        TokenData storage tokenData = tokenIdToTokenData[marbleID];
        tokenData.upgrades[upgradeID] = upgradeLevel;
    }

    function getMarbleUpgrade(uint256 marbleID, uint256 upgradeID) external view returns (uint256) {
        require(_exists(marbleID), "Marble does not exist");
        TokenData storage tokenData = tokenIdToTokenData[marbleID];
        return tokenData.upgrades[upgradeID];
    }

    //Change Marble Manager Address
    function updateMarbleManager(address _manager) public onlyOwner {
        marbleManager = _manager;
    }

    //NEVER RENOUNCE OWNERSHIP
    function renounceOwnership() public override onlyOwner {}

    /////////////////////////////
    //    VIEW IMarketplace    //
    /////////////////////////////

    //Returns mint cost - IMarketplace
    function mintCost(address _minter) public view override returns (uint256) {
        return calculateCurrentMintCost();
    }

    //Returns how many more wallet can mint - IMarketplace
    function canMint(address _minter) external view override returns (uint256) {
        if (mintEnabled == false) {
            return 0;
        }

        if (whitelistOnly == true && isWhitelisted(_minter) == false) {
            return 0;
        }

        if (totalSupply() >= MAX_MINT) {
            return 0;
        }

        return MAX_MINT_PER_TRANSACTION;
    }

    //Returns Max Supply - IMarketplace
    function maxSupply() external view override returns (uint256) {
        return MAX_MINT;
    }

    //Returns Marketplace Data - IMarketplace
    function getInfo() external view override returns (Info memory) {
        //prettier-ignore
        uint256 currentMintCost = calculateCurrentMintCost();
        return
            Info({
                regularCost: currentMintCost,
                memberCost: currentMintCost,
                whitelistCost: currentMintCost,
                maxSupply: MAX_MINT,
                totalSupply: totalSupply(),
                maxMintPerAddress: 0,
                maxMintPerTx: MAX_MINT_PER_TRANSACTION
            });
    }

    //Returns if address has membership
    function isMember(address _address) public view returns (bool) {
        return memberships.isMember(_address);
    }

    //Returns if address is Whitelisted
    function isWhitelisted(address _address) public view returns (bool) {
        return whitelist[_address] || isMember(_address);
    }

    ////////////////////
    //    VIEW ETC    //
    ////////////////////

    //Override baseURI function from ERC721
    function _baseURI() internal view override returns (string memory) {
        return baseURI;
    }

    //Returns owned id list of an address
    function ownedNFTIdList(address _ownerAddress) public view returns (uint256[] memory) {
        uint256 balance = balanceOf(_ownerAddress);

        uint256[] memory allIndexes = new uint256[](balance);
        for (uint256 i = 0; i < balance; i++) {
            uint256 tokenIndex = tokenOfOwnerByIndex(_ownerAddress, i);
            allIndexes[i] = tokenIndex;
        }

        return allIndexes;
    }
}

[{"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":[{"internalType":"address[]","name":"_addresses","type":"address[]"}],"name":"addWhitelist","outputs":[],"stateMutability":"nonpayable","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":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"calculateCurrentMintCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"currentSupply","type":"uint256"}],"name":"calculateMintCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"_minter","type":"address"}],"name":"canMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getInfo","outputs":[{"components":[{"internalType":"uint256","name":"regularCost","type":"uint256"},{"internalType":"uint256","name":"memberCost","type":"uint256"},{"internalType":"uint256","name":"whitelistCost","type":"uint256"},{"internalType":"uint256","name":"maxSupply","type":"uint256"},{"internalType":"uint256","name":"totalSupply","type":"uint256"},{"internalType":"uint256","name":"maxMintPerAddress","type":"uint256"},{"internalType":"uint256","name":"maxMintPerTx","type":"uint256"}],"internalType":"struct IMarketplace.Info","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"marbleID","type":"uint256"},{"internalType":"uint256","name":"upgradeID","type":"uint256"}],"name":"getMarbleUpgrade","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":[{"internalType":"address","name":"_address","type":"address"}],"name":"isMember","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"isWhitelisted","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":"_amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_minter","type":"address"}],"name":"mintCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"mintMarble","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"minters","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_ownerAddress","type":"address"}],"name":"ownedNFTIdList","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"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":"address","name":"dest","type":"address"}],"name":"payments","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"_addresses","type":"address[]"}],"name":"removeWhitelist","outputs":[],"stateMutability":"nonpayable","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":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_mintEnabled","type":"bool"}],"name":"setMintEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_whitelistOnly","type":"bool"}],"name":"setWhitelistOnly","outputs":[],"stateMutability":"nonpayable","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":"uint256","name":"","type":"uint256"}],"name":"tokenIdToTokenData","outputs":[{"internalType":"uint256","name":"id","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":[],"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":"string","name":"_newURI","type":"string"}],"name":"updateBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_manager","type":"address"}],"name":"updateMarbleManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"marbleID","type":"uint256"},{"internalType":"uint256","name":"upgradeID","type":"uint256"},{"internalType":"uint256","name":"upgradeLevel","type":"uint256"}],"name":"updateMarbleUpgrade","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"whitelist","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address payable","name":"payee","type":"address"}],"name":"withdrawPayments","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

54586:8061:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38410:224;;;;;;;;;;-1:-1:-1;38410:224:0;;;;;:::i;:::-;;:::i;:::-;;;9262:14:1;;9255:22;9237:41;;9225:2;9210:18;38410:224:0;;;;;;;;24819:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;26378:221::-;;;;;;;;;;-1:-1:-1;26378:221:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;7696:32:1;;;7678:51;;7666:2;7651:18;26378:221:0;7633:102:1;25901:411:0;;;;;;;;;;-1:-1:-1;25901:411:0;;;;;:::i;:::-;;:::i;:::-;;55160:55;;;;;;;;;;-1:-1:-1;55160:55:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;19903:25:1;;;19891:2;19876:18;55160:55:0;19858:76:1;39050:113:0;;;;;;;;;;-1:-1:-1;39138:10:0;:17;39050:113;;59242:343;;;;;;;;;;-1:-1:-1;59242:343:0;;;;;:::i;:::-;;:::i;58869:216::-;;;;;;;;;;-1:-1:-1;58869:216:0;;;;;:::i;:::-;;:::i;27128:339::-;;;;;;;;;;-1:-1:-1;27128:339:0;;;;;:::i;:::-;;:::i;60278:126::-;;;;;;;;;;-1:-1:-1;60278:126:0;;;;;:::i;:::-;;:::i;38718:256::-;;;;;;;;;;-1:-1:-1;38718:256:0;;;;;:::i;:::-;;:::i;52860:106::-;;;;;;;;;;-1:-1:-1;52860:106:0;;;;;:::i;:::-;;:::i;61809:135::-;;;;;;;;;;-1:-1:-1;61809:135:0;;;;;:::i;:::-;;:::i;27538:185::-;;;;;;;;;;-1:-1:-1;27538:185:0;;;;;:::i;:::-;;:::i;39240:233::-;;;;;;;;;;-1:-1:-1;39240:233:0;;;;;:::i;:::-;;:::i;61057:535::-;;;;;;;;;;;;;:::i;:::-;;;;;;19281:4:1;19323:3;19312:9;19308:19;19300:27;;19360:6;19354:13;19343:9;19336:32;19424:4;19416:6;19412:17;19406:24;19399:4;19388:9;19384:20;19377:54;19487:4;19479:6;19475:17;19469:24;19462:4;19451:9;19447:20;19440:54;19550:4;19542:6;19538:17;19532:24;19525:4;19514:9;19510:20;19503:54;19613:4;19605:6;19601:17;19595:24;19588:4;19577:9;19573:20;19566:54;19676:4;19668:6;19664:17;19658:24;19651:4;19640:9;19636:20;19629:54;19739:4;19731:6;19727:17;19721:24;19714:4;19703:9;19699:20;19692:54;19290:462;;;;;24513:239:0;;;;;;;;;;-1:-1:-1;24513:239:0;;;;;:::i;:::-;;:::i;55380:21::-;;;;;;;;;;;;;:::i;59593:281::-;;;;;;;;;;-1:-1:-1;59593:281:0;;;;;:::i;:::-;;:::i;24243:208::-;;;;;;;;;;-1:-1:-1;24243:208:0;;;;;:::i;:::-;;:::i;60066:57::-;;;;;;;;;;;;;:::i;59919:107::-;;;;;;;;;;-1:-1:-1;59919:107:0;;;;;:::i;:::-;;:::i;62228:416::-;;;;;;;;;;-1:-1:-1;62228:416:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;2031:87::-;;;;;;;;;;-1:-1:-1;2104:6:0;;-1:-1:-1;;;;;2104:6:0;2031:87;;56853:101;;;;;;;;;;-1:-1:-1;56853:101:0;;;;;:::i;:::-;;:::i;24988:104::-;;;;;;;;;;;;;:::i;55222:41::-;;;;;;;;;;-1:-1:-1;55222:41:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;57299:346;;;;;;:::i;:::-;;:::i;26671:155::-;;;;;;;;;;-1:-1:-1;26671:155:0;;;;;:::i;:::-;;:::i;61641:119::-;;;;;;;;;;-1:-1:-1;61641:119:0;;;;;:::i;:::-;;:::i;27794:328::-;;;;;;;;;;-1:-1:-1;27794:328:0;;;;;:::i;:::-;;:::i;56386:267::-;;;;;;;;;;-1:-1:-1;56386:267:0;;;;;:::i;:::-;;:::i;57683:172::-;;;;;;:::i;:::-;;:::i;60472:385::-;;;;;;;;;;-1:-1:-1;60472:385:0;;;;;:::i;:::-;;:::i;25163:334::-;;;;;;;;;;-1:-1:-1;25163:334:0;;;;;:::i;:::-;;:::i;56698:124::-;;;;;;;;;;;;;:::i;60906:96::-;;;;;;;;;;-1:-1:-1;54696:5:0;60906:96;;53090:112;;;;;;;;;;-1:-1:-1;53090:112:0;;;;;:::i;:::-;;:::i;26897:164::-;;;;;;;;;;-1:-1:-1;26897:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;27018:25:0;;;26994:4;27018:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;26897:164;57129:115;;;;;;;;;;-1:-1:-1;57129:115:0;;;;;:::i;:::-;;:::i;58625:212::-;;;;;;;;;;-1:-1:-1;58625:212:0;;;;;:::i;:::-;;:::i;2940:201::-;;;;;;;;;;-1:-1:-1;2940:201:0;;;;;:::i;:::-;;:::i;56985:107::-;;;;;;;;;;-1:-1:-1;56985:107:0;;;;;:::i;:::-;;:::i;55270:42::-;;;;;;;;;;-1:-1:-1;55270:42:0;;;;;:::i;:::-;;;;;;;;;;;;;;38410:224;38512:4;-1:-1:-1;;;;;;38536:50:0;;-1:-1:-1;;;38536:50:0;;:90;;;38590:36;38614:11;38590:23;:36::i;:::-;38529:97;38410:224;-1:-1:-1;;38410:224:0:o;24819:100::-;24873:13;24906:5;24899:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24819:100;:::o;26378:221::-;26454:7;26482:16;26490:7;26482;:16::i;:::-;26474:73;;;;-1:-1:-1;;;26474:73:0;;15134:2:1;26474:73:0;;;15116:21:1;15173:2;15153:18;;;15146:30;15212:34;15192:18;;;15185:62;-1:-1:-1;;;15263:18:1;;;15256:42;15315:19;;26474:73:0;;;;;;;;;-1:-1:-1;26567:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;26567:24:0;;26378:221::o;25901:411::-;25982:13;25998:23;26013:7;25998:14;:23::i;:::-;25982:39;;26046:5;-1:-1:-1;;;;;26040:11:0;:2;-1:-1:-1;;;;;26040:11:0;;;26032:57;;;;-1:-1:-1;;;26032:57:0;;17076:2:1;26032:57:0;;;17058:21:1;17115:2;17095:18;;;17088:30;17154:34;17134:18;;;17127:62;-1:-1:-1;;;17205:18:1;;;17198:31;17246:19;;26032:57:0;17048:223:1;26032:57:0;829:10;-1:-1:-1;;;;;26124:21:0;;;;:62;;-1:-1:-1;26149:37:0;26166:5;829:10;26897:164;:::i;26149:37::-;26102:168;;;;-1:-1:-1;;;26102:168:0;;12832:2:1;26102:168:0;;;12814:21:1;12871:2;12851:18;;;12844:30;12910:34;12890:18;;;12883:62;12981:26;12961:18;;;12954:54;13025:19;;26102:168:0;12804:246:1;26102:168:0;26283:21;26292:2;26296:7;26283:8;:21::i;:::-;25901:411;;;:::o;59242:343::-;55870:13;;-1:-1:-1;;;;;55870:13:0;55856:10;:27;55848:53;;;;-1:-1:-1;;;55848:53:0;;14078:2:1;55848:53:0;;;14060:21:1;14117:2;14097:18;;;14090:30;-1:-1:-1;;;14136:18:1;;;14129:43;14189:18;;55848:53:0;14050:163:1;55848:53:0;59410:17:::1;59418:8;59410:7;:17::i;:::-;59402:51;;;::::0;-1:-1:-1;;;59402:51:0;;11310:2:1;59402:51:0::1;::::0;::::1;11292:21:1::0;11349:2;11329:18;;;11322:30;-1:-1:-1;;;11368:18:1;;;11361:51;11429:18;;59402:51:0::1;11282:171:1::0;59402:51:0::1;59464:27;59494:28:::0;;;:18:::1;:28;::::0;;;;;;;59533:29;;;:18:::1;::::0;;::::1;:29:::0;;;;:44;59242:343::o;58869:216::-;2104:6;;-1:-1:-1;;;;;2104:6:0;829:10;2251:23;2243:68;;;;-1:-1:-1;;;2243:68:0;;;;;;;:::i;:::-;58960:13:::1;58955:123;58979:25:::0;;::::1;58955:123;;;59061:5;59030:9;:28;59040:10;;59051:5;59040:17;;;;;-1:-1:-1::0;;;59040:17:0::1;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;59030:28:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;59030:28:0;:36;;-1:-1:-1;;59030:36:0::1;::::0;::::1;;::::0;;;::::1;::::0;;59006:7;::::1;::::0;::::1;:::i;:::-;;;;58955:123;;27128:339:::0;27323:41;829:10;27356:7;27323:18;:41::i;:::-;27315:103;;;;-1:-1:-1;;;27315:103:0;;;;;;;:::i;:::-;27431:28;27441:4;27447:2;27451:7;27431:9;:28::i;60278:126::-;60343:7;60370:26;:24;:26::i;38718:256::-;38815:7;38851:23;38868:5;38851:16;:23::i;:::-;38843:5;:31;38835:87;;;;-1:-1:-1;;;38835:87:0;;9715:2:1;38835:87:0;;;9697:21:1;9754:2;9734:18;;;9727:30;9793:34;9773:18;;;9766:62;-1:-1:-1;;;9844:18:1;;;9837:41;9895:19;;38835:87:0;9687:233:1;38835:87:0;-1:-1:-1;;;;;;38940:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;38718:256::o;52860:106::-;52935:23;;-1:-1:-1;;;52935:23:0;;-1:-1:-1;;;;;7696:32:1;;;52935:23:0;;;7678:51:1;52935:7:0;:16;;;;7651:18:1;;52935:23:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52860:106;:::o;61809:135::-;-1:-1:-1;;;;;61895:19:0;;61871:4;61895:19;;;:9;:19;;;;;;;;;:41;;;61918:18;61927:8;61918;:18::i;27538:185::-;27676:39;27693:4;27699:2;27703:7;27676:39;;;;;;;;;;;;:16;:39::i;39240:233::-;39315:7;39351:30;39138:10;:17;;39050:113;39351:30;39343:5;:38;39335:95;;;;-1:-1:-1;;;39335:95:0;;18244:2:1;39335:95:0;;;18226:21:1;18283:2;18263:18;;;18256:30;18322:34;18302:18;;;18295:62;-1:-1:-1;;;18373:18:1;;;18366:42;18425:19;;39335:95:0;18216:234:1;39335:95:0;39448:10;39459:5;39448:17;;;;;;-1:-1:-1;;;39448:17:0;;;;;;;;;;;;;;;;;39441:24;;39240:233;;;:::o;61057:535::-;61108:11;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61108:11:0;61159:23;61185:26;:24;:26::i;:::-;61159:52;;61242:342;;;;;;;;61279:15;61242:342;;;;61325:15;61242:342;;;;61374:15;61242:342;;;;54696:5;61242:342;;;;61459:13;39138:10;:17;;39050:113;61459:13;61242:342;;;;61510:1;61242:342;;;;54891:2;61242:342;;;61222:362;;;61057:535;:::o;24513:239::-;24585:7;24621:16;;;:7;:16;;;;;;-1:-1:-1;;;;;24621:16:0;24656:19;24648:73;;;;-1:-1:-1;;;24648:73:0;;13668:2:1;24648:73:0;;;13650:21:1;13707:2;13687:18;;;13680:30;13746:34;13726:18;;;13719:62;-1:-1:-1;;;13797:18:1;;;13790:39;13846:19;;24648:73:0;13640:231:1;55380:21:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;59593:281::-;59679:7;59707:17;59715:8;59707:7;:17::i;:::-;59699:51;;;;-1:-1:-1;;;59699:51:0;;11310:2:1;59699:51:0;;;11292:21:1;11349:2;11329:18;;;11322:30;-1:-1:-1;;;11368:18:1;;;11361:51;11429:18;;59699:51:0;11282:171:1;59699:51:0;-1:-1:-1;59761:27:0;59791:28;;;:18;:28;;;;;;;;59837:29;;;:18;;;;:29;;;;;;59593:281::o;24243:208::-;24315:7;-1:-1:-1;;;;;24343:19:0;;24335:74;;;;-1:-1:-1;;;24335:74:0;;13257:2:1;24335:74:0;;;13239:21:1;13296:2;13276:18;;;13269:30;13335:34;13315:18;;;13308:62;-1:-1:-1;;;13386:18:1;;;13379:40;13436:19;;24335:74:0;13229:232:1;24335:74:0;-1:-1:-1;;;;;;24427:16:0;;;;;:9;:16;;;;;;;24243:208::o;60066:57::-;2104:6;;-1:-1:-1;;;;;2104:6:0;829:10;2251:23;2243:68;;;;-1:-1:-1;;;2243:68:0;;;;;;;:::i;:::-;60066:57::o;59919:107::-;2104:6;;-1:-1:-1;;;;;2104:6:0;829:10;2251:23;2243:68;;;;-1:-1:-1;;;2243:68:0;;;;;;;:::i;:::-;59994:13:::1;:24:::0;;-1:-1:-1;;;;;;59994:24:0::1;-1:-1:-1::0;;;;;59994:24:0;;;::::1;::::0;;;::::1;::::0;;59919:107::o;62228:416::-;62296:16;62325:15;62343:24;62353:13;62343:9;:24::i;:::-;62325:42;;62380:27;62424:7;62410:22;;;;;;-1:-1:-1;;;62410:22:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;62410:22:0;;62380:52;;62448:9;62443:164;62467:7;62463:1;:11;62443:164;;;62496:18;62517:37;62537:13;62552:1;62517:19;:37::i;:::-;62496:58;;62585:10;62569;62580:1;62569:13;;;;;;-1:-1:-1;;;62569:13:0;;;;;;;;;;;;;;;;;;:26;-1:-1:-1;62476:3:0;;;;:::i;:::-;;;;62443:164;;;-1:-1:-1;62626:10:0;62228:416;-1:-1:-1;;;62228:416:0:o;56853:101::-;2104:6;;-1:-1:-1;;;;;2104:6:0;829:10;2251:23;2243:68;;;;-1:-1:-1;;;2243:68:0;;;;;;;:::i;:::-;56929:17;;::::1;::::0;:7:::1;::::0;:17:::1;::::0;::::1;::::0;::::1;:::i;:::-;;56853:101:::0;:::o;24988:104::-;25044:13;25077:7;25070:14;;;;;:::i;57299:346::-;55587:11;;;;55579:37;;;;-1:-1:-1;;;55579:37:0;;16734:2:1;55579:37:0;;;16716:21:1;16773:2;16753:18;;;16746:30;-1:-1:-1;;;16792:18:1;;;16785:43;16845:18;;55579:37:0;16706:163:1;55579:37:0;55686:13:::1;::::0;::::1;::::0;::::1;;;55682:99;;;55724:25;55738:10;55724:13;:25::i;:::-;55716:53;;;::::0;-1:-1:-1;;;55716:53:0;;18657:2:1;55716:53:0::1;::::0;::::1;18639:21:1::0;18696:2;18676:18;;;18669:30;-1:-1:-1;;;18715:18:1;;;18708:45;18770:18;;55716:53:0::1;18629:165:1::0;55716:53:0::1;57399:20:::2;57411:7;57399:11;:20::i;:::-;57432:19;57473:3;57455:14;:9;57467:2;57455:14;:::i;:::-;57454:22;;;;:::i;:::-;57432:44:::0;-1:-1:-1;57487:18:0::2;57508:23;57432:44:::0;57508:9:::2;:23;:::i;:::-;57487:44;;57542:49;55027:42;57579:11;57542:14;:49::i;:::-;57602:35;57617:7;2104:6:::0;;-1:-1:-1;;;;;2104:6:0;;2031:87;57617:7:::2;57626:10;57602:14;:35::i;26671:155::-:0;26766:52;829:10;26799:8;26809;26766:18;:52::i;61641:119::-;61722:11;;:30;;-1:-1:-1;;;61722:30:0;;-1:-1:-1;;;;;7696:32:1;;;61722:30:0;;;7678:51:1;61698:4:0;;61722:11;;:20;;7651:18:1;;61722:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;27794:328::-;27969:41;829:10;28002:7;27969:18;:41::i;:::-;27961:103;;;;-1:-1:-1;;;27961:103:0;;;;;;;:::i;:::-;28075:39;28089:4;28095:2;28099:7;28108:5;28075:13;:39::i;:::-;27794:328;;;;:::o;56386:267::-;56457:7;;56497:39;54751:4;56497:13;:39;:::i;:::-;56477:59;-1:-1:-1;56547:16:0;56582:26;56477:59;54838:2;56582:26;:::i;:::-;56566:42;;54795:2;56566:42;:::i;:::-;56547:61;-1:-1:-1;56626:19:0;56547:61;56638:6;56626:19;:::i;:::-;56619:26;56386:267;-1:-1:-1;;;;56386:267:0:o;57683:172::-;55587:11;;;;55579:37;;;;-1:-1:-1;;;55579:37:0;;16734:2:1;55579:37:0;;;16716:21:1;16773:2;16753:18;;;16746:30;-1:-1:-1;;;16792:18:1;;;16785:43;16845:18;;55579:37:0;16706:163:1;55579:37:0;55686:13:::1;::::0;::::1;::::0;::::1;;;55682:99;;;55724:25;55738:10;55724:13;:25::i;:::-;55716:53;;;::::0;-1:-1:-1;;;55716:53:0;;18657:2:1;55716:53:0::1;::::0;::::1;18639:21:1::0;18696:2;18676:18;;;18669:30;-1:-1:-1;;;18715:18:1;;;18708:45;18770:18;;55716:53:0::1;18629:165:1::0;55716:53:0::1;57780:20:::2;57792:7;57780:11;:20::i;:::-;57813:34;57828:7;2104:6:::0;;-1:-1:-1;;;;;2104:6:0;;2031:87;57828:7:::2;57837:9;57813:14;:34::i;:::-;57683:172:::0;:::o;60472:385::-;60562:11;;60538:7;;60562:11;;60558:61;;-1:-1:-1;60606:1:0;;60472:385;-1:-1:-1;60472:385:0:o;60558:61::-;60635:13;;;;;;;;:21;;:13;:21;:56;;;;;60660:22;60674:7;60660:13;:22::i;:::-;:31;60635:56;60631:97;;;-1:-1:-1;60715:1:0;;60472:385;-1:-1:-1;60472:385:0:o;60631:97::-;54696:5;60744:13;39138:10;:17;;39050:113;60744:13;:25;60740:66;;-1:-1:-1;60793:1:0;;60472:385;-1:-1:-1;60472:385:0:o;60740:66::-;-1:-1:-1;54891:2:0;;60472:385;-1:-1:-1;60472:385:0:o;25163:334::-;25236:13;25270:16;25278:7;25270;:16::i;:::-;25262:76;;;;-1:-1:-1;;;25262:76:0;;16318:2:1;25262:76:0;;;16300:21:1;16357:2;16337:18;;;16330:30;16396:34;16376:18;;;16369:62;-1:-1:-1;;;16447:18:1;;;16440:45;16502:19;;25262:76:0;16290:237:1;25262:76:0;25351:21;25375:10;:8;:10::i;:::-;25351:34;;25427:1;25409:7;25403:21;:25;:86;;;;;;;;;;;;;;;;;25455:7;25464:18;:7;:16;:18::i;:::-;25438:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;25403:86;25396:93;25163:334;-1:-1:-1;;;25163:334:0:o;56698:124::-;56755:7;56782:32;56800:13;39138:10;:17;;39050:113;56782:32;56775:39;;56698:124;:::o;53090:112::-;53170:24;;-1:-1:-1;;;53170:24:0;;-1:-1:-1;;;;;7696:32:1;;;53170:24:0;;;7678:51:1;53143:7:0;;53170;:18;;;;;;7651::1;;53170:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;57129:115::-;2104:6;;-1:-1:-1;;;;;2104:6:0;829:10;2251:23;2243:68;;;;-1:-1:-1;;;2243:68:0;;;;;;;:::i;:::-;57206:13:::1;:30:::0;;;::::1;;;;-1:-1:-1::0;;57206:30:0;;::::1;::::0;;;::::1;::::0;;57129:115::o;58625:212::-;2104:6;;-1:-1:-1;;;;;2104:6:0;829:10;2251:23;2243:68;;;;-1:-1:-1;;;2243:68:0;;;;;;;:::i;:::-;58713:13:::1;58708:122;58732:25:::0;;::::1;58708:122;;;58814:4;58783:9;:28;58793:10;;58804:5;58793:17;;;;;-1:-1:-1::0;;;58793:17:0::1;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;58783:28:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;58783:28:0;:35;;-1:-1:-1;;58783:35:0::1;::::0;::::1;;::::0;;;::::1;::::0;;58759:7;::::1;::::0;::::1;:::i;:::-;;;;58708:122;;2940:201:::0;2104:6;;-1:-1:-1;;;;;2104:6:0;829:10;2251:23;2243:68;;;;-1:-1:-1;;;2243:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;3029:22:0;::::1;3021:73;;;::::0;-1:-1:-1;;;3021:73:0;;10546:2:1;3021:73:0::1;::::0;::::1;10528:21:1::0;10585:2;10565:18;;;10558:30;10624:34;10604:18;;;10597:62;-1:-1:-1;;;10675:18:1;;;10668:36;10721:19;;3021:73:0::1;10518:228:1::0;3021:73:0::1;3105:28;3124:8;3105:18;:28::i;56985:107::-:0;2104:6;;-1:-1:-1;;;;;2104:6:0;829:10;2251:23;2243:68;;;;-1:-1:-1;;;2243:68:0;;;;;;;:::i;:::-;57058:11:::1;:26:::0;;-1:-1:-1;;57058:26:0::1;::::0;::::1;;::::0;;;::::1;::::0;;56985:107::o;23874:305::-;23976:4;-1:-1:-1;;;;;;24013:40:0;;-1:-1:-1;;;24013:40:0;;:105;;-1:-1:-1;;;;;;;24070:48:0;;-1:-1:-1;;;24070:48:0;24013:105;:158;;;-1:-1:-1;;;;;;;;;;22421:40:0;;;24135:36;22312:157;29632:127;29697:4;29721:16;;;:7;:16;;;;;;-1:-1:-1;;;;;29721:16:0;:30;;;29632:127::o;33614:174::-;33689:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;33689:29:0;-1:-1:-1;;;;;33689:29:0;;;;;;;;:24;;33743:23;33689:24;33743:14;:23::i;:::-;-1:-1:-1;;;;;33734:46:0;;;;;;;;;;;33614:174;;:::o;29926:348::-;30019:4;30044:16;30052:7;30044;:16::i;:::-;30036:73;;;;-1:-1:-1;;;30036:73:0;;12419:2:1;30036:73:0;;;12401:21:1;12458:2;12438:18;;;12431:30;12497:34;12477:18;;;12470:62;-1:-1:-1;;;12548:18:1;;;12541:42;12600:19;;30036:73:0;12391:234:1;30036:73:0;30120:13;30136:23;30151:7;30136:14;:23::i;:::-;30120:39;;30189:5;-1:-1:-1;;;;;30178:16:0;:7;-1:-1:-1;;;;;30178:16:0;;:51;;;;30222:7;-1:-1:-1;;;;;30198:31:0;:20;30210:7;30198:11;:20::i;:::-;-1:-1:-1;;;;;30198:31:0;;30178:51;:87;;;-1:-1:-1;;;;;;27018:25:0;;;26994:4;27018:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;30233:32;26897:164;32918:578;33077:4;-1:-1:-1;;;;;33050:31:0;:23;33065:7;33050:14;:23::i;:::-;-1:-1:-1;;;;;33050:31:0;;33042:85;;;;-1:-1:-1;;;33042:85:0;;15908:2:1;33042:85:0;;;15890:21:1;15947:2;15927:18;;;15920:30;15986:34;15966:18;;;15959:62;-1:-1:-1;;;16037:18:1;;;16030:39;16086:19;;33042:85:0;15880:231:1;33042:85:0;-1:-1:-1;;;;;33146:16:0;;33138:65;;;;-1:-1:-1;;;33138:65:0;;11660:2:1;33138:65:0;;;11642:21:1;11699:2;11679:18;;;11672:30;11738:34;11718:18;;;11711:62;-1:-1:-1;;;11789:18:1;;;11782:34;11833:19;;33138:65:0;11632:226:1;33138:65:0;33216:39;33237:4;33243:2;33247:7;33216:20;:39::i;:::-;33320:29;33337:1;33341:7;33320:8;:29::i;:::-;-1:-1:-1;;;;;33362:15:0;;;;;;:9;:15;;;;;:20;;33381:1;;33362:15;:20;;33381:1;;33362:20;:::i;:::-;;;;-1:-1:-1;;;;;;;33393:13:0;;;;;;:9;:13;;;;;:18;;33410:1;;33393:13;:18;;33410:1;;33393:18;:::i;:::-;;;;-1:-1:-1;;33422:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;33422:21:0;-1:-1:-1;;;;;33422:21:0;;;;;;;;;33461:27;;33422:16;;33461:27;;;;;;;32918:578;;;:::o;57892:704::-;54891:2;57957:7;:35;;57949:67;;;;-1:-1:-1;;;57949:67:0;;17896:2:1;57949:67:0;;;17878:21:1;17935:2;17915:18;;;17908:30;-1:-1:-1;;;17954:18:1;;;17947:49;18013:18;;57949:67:0;17868:169:1;57949:67:0;58045:1;58035:7;:11;58027:43;;;;-1:-1:-1;;;58027:43:0;;17896:2:1;58027:43:0;;;17878:21:1;17935:2;17915:18;;;17908:30;-1:-1:-1;;;17954:18:1;;;17947:49;18013:18;;58027:43:0;17868:169:1;58027:43:0;54696:5;58105:7;58089:13;39138:10;:17;;39050:113;58089:13;:23;;;;:::i;:::-;:35;;58081:72;;;;-1:-1:-1;;;58081:72:0;;14420:2:1;58081:72:0;;;14402:21:1;14459:2;14439:18;;;14432:30;14498:26;14478:18;;;14471:54;14542:18;;58081:72:0;14392:174:1;58081:72:0;58166:22;58214:7;58191:20;58200:10;58191:8;:20::i;:::-;:30;;;;:::i;:::-;58166:55;;58258:9;58240:14;:27;58232:57;;;;-1:-1:-1;;;58232:57:0;;19001:2:1;58232:57:0;;;18983:21:1;19040:2;19020:18;;;19013:30;-1:-1:-1;;;19059:18:1;;;19052:47;19116:18;;58232:57:0;18973:167:1;58232:57:0;58307:9;58302:244;58326:7;58322:1;:11;58302:244;;;58355:13;58371;39138:10;:17;;39050:113;58371:13;:17;;58387:1;58371:17;:::i;:::-;58355:33;;58403:28;58413:10;58425:5;58403:9;:28::i;:::-;58446:26;58475:25;;;:18;:25;;;;;58515:19;58335:3;;;;:::i;:::-;;;;58302:244;;;-1:-1:-1;58566:10:0;58558:19;;;;:7;:19;;;;;:30;;58581:7;;58558:19;:30;;58581:7;;58558:30;:::i;:::-;;;;-1:-1:-1;;;;57892:704:0:o;53571:126::-;53653:36;;-1:-1:-1;;;53653:36:0;;-1:-1:-1;;;;;7696:32:1;;;53653:36:0;;;7678:51:1;53653:7:0;:15;;;;53676:6;;7651:18:1;;53653:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53571:126;;:::o;33930:315::-;34085:8;-1:-1:-1;;;;;34076:17:0;:5;-1:-1:-1;;;;;34076:17:0;;;34068:55;;;;-1:-1:-1;;;34068:55:0;;12065:2:1;34068:55:0;;;12047:21:1;12104:2;12084:18;;;12077:30;12143:27;12123:18;;;12116:55;12188:18;;34068:55:0;12037:175:1;34068:55:0;-1:-1:-1;;;;;34134:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;34134:46:0;;;;;;;;;;34196:41;;9237::1;;;34196::0;;9210:18:1;34196:41:0;;;;;;;33930:315;;;:::o;29004:::-;29161:28;29171:4;29177:2;29181:7;29161:9;:28::i;:::-;29208:48;29231:4;29237:2;29241:7;29250:5;29208:22;:48::i;:::-;29200:111;;;;-1:-1:-1;;;29200:111:0;;;;;;;:::i;62077:100::-;62129:13;62162:7;62155:14;;;;;:::i;19682:723::-;19738:13;19959:10;19955:53;;-1:-1:-1;;19986:10:0;;;;;;;;;;;;-1:-1:-1;;;19986:10:0;;;;;19682:723::o;19955:53::-;20033:5;20018:12;20074:78;20081:9;;20074:78;;20107:8;;;;:::i;:::-;;-1:-1:-1;20130:10:0;;-1:-1:-1;20138:2:0;20130:10;;:::i;:::-;;;20074:78;;;20162:19;20194:6;20184:17;;;;;;-1:-1:-1;;;20184:17:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20184:17:0;;20162:39;;20212:154;20219:10;;20212:154;;20246:11;20256:1;20246:11;;:::i;:::-;;-1:-1:-1;20315:10:0;20323:2;20315:5;:10;:::i;:::-;20302:24;;:2;:24;:::i;:::-;20289:39;;20272:6;20279;20272:14;;;;;;-1:-1:-1;;;20272:14:0;;;;;;;;;;;;:56;-1:-1:-1;;;;;20272:56:0;;;;;;;;-1:-1:-1;20343:11:0;20352:2;20343:11;;:::i;:::-;;;20212:154;;3301:191;3394:6;;;-1:-1:-1;;;;;3411:17:0;;;-1:-1:-1;;;;;;3411:17:0;;;;;;;3444:40;;3394:6;;;3411:17;3394:6;;3444:40;;3375:16;;3444:40;3301:191;;:::o;40086:589::-;-1:-1:-1;;;;;40292:18:0;;40288:187;;40327:40;40359:7;41502:10;:17;;41475:24;;;;:15;:24;;;;;:44;;;41530:24;;;;;;;;;;;;41398:164;40327:40;40288:187;;;40397:2;-1:-1:-1;;;;;40389:10:0;:4;-1:-1:-1;;;;;40389:10:0;;40385:90;;40416:47;40449:4;40455:7;40416:32;:47::i;:::-;-1:-1:-1;;;;;40489:16:0;;40485:183;;40522:45;40559:7;40522:36;:45::i;40485:183::-;40595:4;-1:-1:-1;;;;;40589:10:0;:2;-1:-1:-1;;;;;40589:10:0;;40585:83;;40616:40;40644:2;40648:7;40616:27;:40::i;30616:110::-;30692:26;30702:2;30706:7;30692:26;;;;;;;;;;;;:9;:26::i;34810:799::-;34965:4;-1:-1:-1;;;;;34986:13:0;;12301:20;12349:8;34982:620;;35022:72;;-1:-1:-1;;;35022:72:0;;-1:-1:-1;;;;;35022:36:0;;;;;:72;;829:10;;35073:4;;35079:7;;35088:5;;35022:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;35022:72:0;;;;;;;;-1:-1:-1;;35022:72:0;;;;;;;;;;;;:::i;:::-;;;35018:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;35264:13:0;;35260:272;;35307:60;;-1:-1:-1;;;35307:60:0;;;;;;;:::i;35260:272::-;35482:6;35476:13;35467:6;35463:2;35459:15;35452:38;35018:529;-1:-1:-1;;;;;;35145:51:0;-1:-1:-1;;;35145:51:0;;-1:-1:-1;35138:58:0;;34982:620;-1:-1:-1;35586:4:0;34810:799;;;;;;:::o;42189:988::-;42455:22;42505:1;42480:22;42497:4;42480:16;:22::i;:::-;:26;;;;:::i;:::-;42517:18;42538:26;;;:17;:26;;;;;;42455:51;;-1:-1:-1;42671:28:0;;;42667:328;;-1:-1:-1;;;;;42738:18:0;;42716:19;42738:18;;;:12;:18;;;;;;;;:34;;;;;;;;;42789:30;;;;;;:44;;;42906:30;;:17;:30;;;;;:43;;;42667:328;-1:-1:-1;43091:26:0;;;;:17;:26;;;;;;;;43084:33;;;-1:-1:-1;;;;;43135:18:0;;;;;:12;:18;;;;;:34;;;;;;;43128:41;42189:988::o;43472:1079::-;43750:10;:17;43725:22;;43750:21;;43770:1;;43750:21;:::i;:::-;43782:18;43803:24;;;:15;:24;;;;;;44176:10;:26;;43725:46;;-1:-1:-1;43803:24:0;;43725:46;;44176:26;;;;-1:-1:-1;;;44176:26:0;;;;;;;;;;;;;;;;;44154:48;;44240:11;44215:10;44226;44215:22;;;;;;-1:-1:-1;;;44215:22:0;;;;;;;;;;;;;;;;;;;;:36;;;;44320:28;;;:15;:28;;;;;;;:41;;;44492:24;;;;;44485:31;44527:10;:16;;;;;-1:-1:-1;;;44527:16:0;;;;;;;;;;;;;;;;;;;;;;;;;;43472:1079;;;;:::o;40976:221::-;41061:14;41078:20;41095:2;41078:16;:20::i;:::-;-1:-1:-1;;;;;41109:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;41154:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;40976:221:0:o;30953:321::-;31083:18;31089:2;31093:7;31083:5;:18::i;:::-;31134:54;31165:1;31169:2;31173:7;31182:5;31134:22;:54::i;:::-;31112:154;;;;-1:-1:-1;;;31112:154:0;;;;;;;:::i;31610:382::-;-1:-1:-1;;;;;31690:16:0;;31682:61;;;;-1:-1:-1;;;31682:61:0;;14773:2:1;31682:61:0;;;14755:21:1;;;14792:18;;;14785:30;14851:34;14831:18;;;14824:62;14903:18;;31682:61:0;14745:182:1;31682:61:0;31763:16;31771:7;31763;:16::i;:::-;31762:17;31754:58;;;;-1:-1:-1;;;31754:58:0;;10953:2:1;31754:58:0;;;10935:21:1;10992:2;10972:18;;;10965:30;11031;11011:18;;;11004:58;11079:18;;31754:58:0;10925:178:1;31754:58:0;31825:45;31854:1;31858:2;31862:7;31825:20;:45::i;:::-;-1:-1:-1;;;;;31883:13:0;;;;;;:9;:13;;;;;:18;;31900:1;;31883:13;:18;;31900:1;;31883:18;:::i;:::-;;;;-1:-1:-1;;31912:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;31912:21:0;-1:-1:-1;;;;;31912:21:0;;;;;;;;31951:33;;31912:16;;;31951:33;;31912:16;;31951:33;31610:382;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:631:1;78:5;108:18;149:2;141:6;138:14;135:2;;;155:18;;:::i;:::-;230:2;224:9;198:2;284:15;;-1:-1:-1;;280:24:1;;;306:2;276:33;272:42;260:55;;;330:18;;;350:22;;;327:46;324:2;;;376:18;;:::i;:::-;416:10;412:2;405:22;445:6;436:15;;475:6;467;460:22;515:3;506:6;501:3;497:16;494:25;491:2;;;532:1;529;522:12;491:2;582:6;577:3;570:4;562:6;558:17;545:44;637:1;630:4;621:6;613;609:19;605:30;598:41;;;;88:557;;;;;:::o;650:257::-;709:6;762:2;750:9;741:7;737:23;733:32;730:2;;;783:6;775;768:22;730:2;827:9;814:23;846:31;871:5;846:31;:::i;1182:398::-;1250:6;1258;1311:2;1299:9;1290:7;1286:23;1282:32;1279:2;;;1332:6;1324;1317:22;1279:2;1376:9;1363:23;1395:31;1420:5;1395:31;:::i;:::-;1445:5;-1:-1:-1;1502:2:1;1487:18;;1474:32;1515:33;1474:32;1515:33;:::i;:::-;1567:7;1557:17;;;1269:311;;;;;:::o;1585:466::-;1662:6;1670;1678;1731:2;1719:9;1710:7;1706:23;1702:32;1699:2;;;1752:6;1744;1737:22;1699:2;1796:9;1783:23;1815:31;1840:5;1815:31;:::i;:::-;1865:5;-1:-1:-1;1922:2:1;1907:18;;1894:32;1935:33;1894:32;1935:33;:::i;:::-;1689:362;;1987:7;;-1:-1:-1;;;2041:2:1;2026:18;;;;2013:32;;1689:362::o;2056:824::-;2151:6;2159;2167;2175;2228:3;2216:9;2207:7;2203:23;2199:33;2196:2;;;2250:6;2242;2235:22;2196:2;2294:9;2281:23;2313:31;2338:5;2313:31;:::i;:::-;2363:5;-1:-1:-1;2420:2:1;2405:18;;2392:32;2433:33;2392:32;2433:33;:::i;:::-;2485:7;-1:-1:-1;2539:2:1;2524:18;;2511:32;;-1:-1:-1;2594:2:1;2579:18;;2566:32;2621:18;2610:30;;2607:2;;;2658:6;2650;2643:22;2607:2;2686:22;;2739:4;2731:13;;2727:27;-1:-1:-1;2717:2:1;;2773:6;2765;2758:22;2717:2;2801:73;2866:7;2861:2;2848:16;2843:2;2839;2835:11;2801:73;:::i;:::-;2791:83;;;2186:694;;;;;;;:::o;2885:392::-;2950:6;2958;3011:2;2999:9;2990:7;2986:23;2982:32;2979:2;;;3032:6;3024;3017:22;2979:2;3076:9;3063:23;3095:31;3120:5;3095:31;:::i;:::-;3145:5;-1:-1:-1;3202:2:1;3187:18;;3174:32;3215:30;3174:32;3215:30;:::i;3282:325::-;3350:6;3358;3411:2;3399:9;3390:7;3386:23;3382:32;3379:2;;;3432:6;3424;3417:22;3379:2;3476:9;3463:23;3495:31;3520:5;3495:31;:::i;:::-;3545:5;3597:2;3582:18;;;;3569:32;;-1:-1:-1;;;3369:238:1:o;3612:665::-;3698:6;3706;3759:2;3747:9;3738:7;3734:23;3730:32;3727:2;;;3780:6;3772;3765:22;3727:2;3825:9;3812:23;3854:18;3895:2;3887:6;3884:14;3881:2;;;3916:6;3908;3901:22;3881:2;3959:6;3948:9;3944:22;3934:32;;4004:7;3997:4;3993:2;3989:13;3985:27;3975:2;;4031:6;4023;4016:22;3975:2;4076;4063:16;4102:2;4094:6;4091:14;4088:2;;;4123:6;4115;4108:22;4088:2;4181:7;4176:2;4166:6;4163:1;4159:14;4155:2;4151:23;4147:32;4144:45;4141:2;;;4207:6;4199;4192:22;4141:2;4243;4235:11;;;;;4265:6;;-1:-1:-1;3717:560:1;;-1:-1:-1;;;;3717:560:1:o;4282:251::-;4338:6;4391:2;4379:9;4370:7;4366:23;4362:32;4359:2;;;4412:6;4404;4397:22;4359:2;4456:9;4443:23;4475:28;4497:5;4475:28;:::i;4538:255::-;4605:6;4658:2;4646:9;4637:7;4633:23;4629:32;4626:2;;;4679:6;4671;4664:22;4626:2;4716:9;4710:16;4735:28;4757:5;4735:28;:::i;4798:255::-;4856:6;4909:2;4897:9;4888:7;4884:23;4880:32;4877:2;;;4930:6;4922;4915:22;4877:2;4974:9;4961:23;4993:30;5017:5;4993:30;:::i;5058:259::-;5127:6;5180:2;5168:9;5159:7;5155:23;5151:32;5148:2;;;5201:6;5193;5186:22;5148:2;5238:9;5232:16;5257:30;5281:5;5257:30;:::i;5322:480::-;5391:6;5444:2;5432:9;5423:7;5419:23;5415:32;5412:2;;;5465:6;5457;5450:22;5412:2;5510:9;5497:23;5543:18;5535:6;5532:30;5529:2;;;5580:6;5572;5565:22;5529:2;5608:22;;5661:4;5653:13;;5649:27;-1:-1:-1;5639:2:1;;5695:6;5687;5680:22;5639:2;5723:73;5788:7;5783:2;5770:16;5765:2;5761;5757:11;5723:73;:::i;5807:190::-;5866:6;5919:2;5907:9;5898:7;5894:23;5890:32;5887:2;;;5940:6;5932;5925:22;5887:2;-1:-1:-1;5968:23:1;;5877:120;-1:-1:-1;5877:120:1:o;6002:194::-;6072:6;6125:2;6113:9;6104:7;6100:23;6096:32;6093:2;;;6146:6;6138;6131:22;6093:2;-1:-1:-1;6174:16:1;;6083:113;-1:-1:-1;6083:113:1:o;6201:258::-;6269:6;6277;6330:2;6318:9;6309:7;6305:23;6301:32;6298:2;;;6351:6;6343;6336:22;6298:2;-1:-1:-1;;6379:23:1;;;6449:2;6434:18;;;6421:32;;-1:-1:-1;6288:171:1:o;6464:326::-;6541:6;6549;6557;6610:2;6598:9;6589:7;6585:23;6581:32;6578:2;;;6631:6;6623;6616:22;6578:2;-1:-1:-1;;6659:23:1;;;6729:2;6714:18;;6701:32;;-1:-1:-1;6780:2:1;6765:18;;;6752:32;;6568:222;-1:-1:-1;6568:222:1:o;6795:257::-;6836:3;6874:5;6868:12;6901:6;6896:3;6889:19;6917:63;6973:6;6966:4;6961:3;6957:14;6950:4;6943:5;6939:16;6917:63;:::i;:::-;7034:2;7013:15;-1:-1:-1;;7009:29:1;7000:39;;;;7041:4;6996:50;;6844:208;-1:-1:-1;;6844:208:1:o;7057:470::-;7236:3;7274:6;7268:13;7290:53;7336:6;7331:3;7324:4;7316:6;7312:17;7290:53;:::i;:::-;7406:13;;7365:16;;;;7428:57;7406:13;7365:16;7462:4;7450:17;;7428:57;:::i;:::-;7501:20;;7244:283;-1:-1:-1;;;;7244:283:1:o;7964:488::-;-1:-1:-1;;;;;8233:15:1;;;8215:34;;8285:15;;8280:2;8265:18;;8258:43;8332:2;8317:18;;8310:34;;;8380:3;8375:2;8360:18;;8353:31;;;8158:4;;8401:45;;8426:19;;8418:6;8401:45;:::i;:::-;8393:53;8167:285;-1:-1:-1;;;;;;8167:285:1:o;8457:635::-;8628:2;8680:21;;;8750:13;;8653:18;;;8772:22;;;8599:4;;8628:2;8851:15;;;;8825:2;8810:18;;;8599:4;8897:169;8911:6;8908:1;8905:13;8897:169;;;8972:13;;8960:26;;9041:15;;;;9006:12;;;;8933:1;8926:9;8897:169;;;-1:-1:-1;9083:3:1;;8608:484;-1:-1:-1;;;;;;8608:484:1:o;9289:219::-;9438:2;9427:9;9420:21;9401:4;9458:44;9498:2;9487:9;9483:18;9475:6;9458:44;:::i;9925:414::-;10127:2;10109:21;;;10166:2;10146:18;;;10139:30;10205:34;10200:2;10185:18;;10178:62;-1:-1:-1;;;10271:2:1;10256:18;;10249:48;10329:3;10314:19;;10099:240::o;15345:356::-;15547:2;15529:21;;;15566:18;;;15559:30;15625:34;15620:2;15605:18;;15598:62;15692:2;15677:18;;15519:182::o;17276:413::-;17478:2;17460:21;;;17517:2;17497:18;;;17490:30;17556:34;17551:2;17536:18;;17529:62;-1:-1:-1;;;17622:2:1;17607:18;;17600:47;17679:3;17664:19;;17450:239::o;19939:128::-;19979:3;20010:1;20006:6;20003:1;20000:13;19997:2;;;20016:18;;:::i;:::-;-1:-1:-1;20052:9:1;;19987:80::o;20072:120::-;20112:1;20138;20128:2;;20143:18;;:::i;:::-;-1:-1:-1;20177:9:1;;20118:74::o;20197:168::-;20237:7;20303:1;20299;20295:6;20291:14;20288:1;20285:21;20280:1;20273:9;20266:17;20262:45;20259:2;;;20310:18;;:::i;:::-;-1:-1:-1;20350:9:1;;20249:116::o;20370:125::-;20410:4;20438:1;20435;20432:8;20429:2;;;20443:18;;:::i;:::-;-1:-1:-1;20480:9:1;;20419:76::o;20500:258::-;20572:1;20582:113;20596:6;20593:1;20590:13;20582:113;;;20672:11;;;20666:18;20653:11;;;20646:39;20618:2;20611:10;20582:113;;;20713:6;20710:1;20707:13;20704:2;;;-1:-1:-1;;20748:1:1;20730:16;;20723:27;20553:205::o;20763:380::-;20842:1;20838:12;;;;20885;;;20906:2;;20960:4;20952:6;20948:17;20938:27;;20906:2;21013;21005:6;21002:14;20982:18;20979:38;20976:2;;;21059:10;21054:3;21050:20;21047:1;21040:31;21094:4;21091:1;21084:15;21122:4;21119:1;21112:15;20976:2;;20818:325;;;:::o;21148:135::-;21187:3;-1:-1:-1;;21208:17:1;;21205:2;;;21228:18;;:::i;:::-;-1:-1:-1;21275:1:1;21264:13;;21195:88::o;21288:112::-;21320:1;21346;21336:2;;21351:18;;:::i;:::-;-1:-1:-1;21385:9:1;;21326:74::o;21405:127::-;21466:10;21461:3;21457:20;21454:1;21447:31;21497:4;21494:1;21487:15;21521:4;21518:1;21511:15;21537:127;21598:10;21593:3;21589:20;21586:1;21579:31;21629:4;21626:1;21619:15;21653:4;21650:1;21643:15;21669:127;21730:10;21725:3;21721:20;21718:1;21711:31;21761:4;21758:1;21751:15;21785:4;21782:1;21775:15;21801:131;-1:-1:-1;;;;;21876:31:1;;21866:42;;21856:2;;21922:1;21919;21912:12;21937:118;22023:5;22016:13;22009:21;22002:5;21999:32;21989:2;;22045:1;22042;22035:12;22060:131;-1:-1:-1;;;;;;22134:32:1;;22124:43;;22114:2;;22181:1;22178;22171:12

ipfs://88702fd4ddcea429b86ffcb261f544be05e79d5fd7b90a9f3a7ecefbe3b90e2c