Contract 0x3969c4970f037c151655b41dcfd3e0c377206206

/**
 *Submitted for verification at Arbiscan on 2021-10-28
*/

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



pragma solidity ^0.8.0;

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

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

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

        _;

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

// File: @openzeppelin/contracts/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/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/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/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/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/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/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/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/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 {
        require(operator != _msgSender(), "ERC721: approve to caller");

        _operatorApprovals[_msgSender()][operator] = approved;
        emit ApprovalForAll(_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 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/ERC721URIStorage.sol



pragma solidity ^0.8.0;


/**
 * @dev ERC721 token with storage based token URI management.
 */
abstract contract ERC721URIStorage is ERC721 {
    using Strings for uint256;

    // Optional mapping for token URIs
    mapping(uint256 => string) private _tokenURIs;

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

        string memory _tokenURI = _tokenURIs[tokenId];
        string memory base = _baseURI();

        // If there is no base URI, return the token URI.
        if (bytes(base).length == 0) {
            return _tokenURI;
        }
        // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
        if (bytes(_tokenURI).length > 0) {
            return string(abi.encodePacked(base, _tokenURI));
        }

        return super.tokenURI(tokenId);
    }

    /**
     * @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
        require(_exists(tokenId), "ERC721URIStorage: URI set of nonexistent token");
        _tokenURIs[tokenId] = _tokenURI;
    }

    /**
     * @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 override {
        super._burn(tokenId);

        if (bytes(_tokenURIs[tokenId]).length != 0) {
            delete _tokenURIs[tokenId];
        }
    }
}

// File: @openzeppelin/contracts/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() {
        _setOwner(_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 {
        _setOwner(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");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// File: @openzeppelin/contracts/utils/Counters.sol



pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}

// File: contracts/Marketplace.sol


pragma solidity ^0.8.0;







contract NFTMarket is ReentrancyGuard, Ownable, IERC721Receiver {
    using Counters for Counters.Counter;
    Counters.Counter private _itemIds;
    Counters.Counter private _itemsSold;

    // PLATFORM ROYALTIES
    uint256 private MAX_SALE_FEE = 250;
    uint256 public saleFee = 250;

    uint256 private MAX_CREATOR_FEE = 1000;

    mapping(address => bool) private contractsAuthorized;

    // NFT COLLECTION MAPPINGS
    // address = collection contract

    mapping(address => uint256) private contractVolume;

    mapping(address => uint256) private creatorFee;

    mapping(address => address payable) private creatorAddress;

    //////////////////////////// END

    mapping(address => uint256) private creatorRoyalties;

    uint256 totalFees = 0;

    struct MarketItem {
        uint256 itemId;
        address nftContract;
        uint256 tokenId;
        address payable seller;
        address payable owner;
        uint256 price;
        bool sold;
    }

    mapping(uint256 => MarketItem) private idToMarketItem;

    event MarketItemCreated(
        uint256 indexed itemId,
        address indexed nftContract,
        uint256 indexed tokenId,
        address seller,
        address owner,
        uint256 price,
        bool sold
    );

    event MarketItemSale(
        uint256 indexed itemId,
        address indexed nftContract,
        uint256 indexed tokenId,
        address seller,
        address newOwner,
        uint256 price
    );

    event MarketItemDelist(
        uint256 indexed itemId,
        address indexed nftContract,
        address seller
    );

    event WithdrawRoyalties(
        address indexed nftContract,
        address creator,
        uint256 royalties
    );

    modifier isAuthorized(address _nftContract) {
        require(contractsAuthorized[_nftContract]);
        _;
    }

    function setSaleFee(uint256 _fee) public onlyOwner {
        require(_fee <= MAX_SALE_FEE, "Fee can't be greater than MAX_SALE_FEE");
        saleFee = _fee;
    }

    function getNumberItemsSold() public view returns (uint256) {
        return _itemsSold.current();
    }

    function getContractVolume(address _nftContract)
        public
        view
        returns (uint256)
    {
        return contractVolume[_nftContract];
    }

    function getCreatorFee(address _nftContract) public view returns (uint256) {
        return creatorFee[_nftContract];
    }

    function addCollection(
        address _nftContract,
        uint256 _creatorFee,
        address _creatorAddress
    ) public onlyOwner {
        contractsAuthorized[_nftContract] = true;
        creatorFee[_nftContract] = _creatorFee;
        creatorAddress[_nftContract] = payable(_creatorAddress);
    }

    function isContractAuthorized(address _nftContract)
        public
        view
        returns (bool)
    {
        return contractsAuthorized[_nftContract];
    }

    function onERC721Received(
        address,
        address,
        uint256,
        bytes memory
    ) public virtual override returns (bytes4) {
        return this.onERC721Received.selector;
    }

    /* LISTING FUNCTION */
    function createMarketItem(
        address nftContract,
        uint256 tokenId,
        uint256 price
    ) public payable nonReentrant isAuthorized(nftContract) {
        require(price > 0, "Price must be at least 1 wei");

        _itemIds.increment();
        uint256 itemId = _itemIds.current();

        idToMarketItem[itemId] = MarketItem(
            itemId,
            nftContract,
            tokenId,
            payable(msg.sender),
            payable(address(0)), // SET OWNER TO 0x0
            price,
            false // NOT SOLD
        );

        IERC721(nftContract).safeTransferFrom(
            msg.sender,
            address(this),
            tokenId
        );

        emit MarketItemCreated(
            itemId,
            nftContract,
            tokenId,
            msg.sender,
            address(0),
            price,
            false
        );
    }

    /* BUY ITEM */
    function createMarketSale(address nftContract, uint256 itemId)
        public
        payable
        nonReentrant
        isAuthorized(nftContract)
    {
        uint256 price = idToMarketItem[itemId].price;
        uint256 tokenId = idToMarketItem[itemId].tokenId;
        require(
            msg.value == price,
            "Please submit the asking price in order to complete the purchase"
        );
        require(
            idToMarketItem[itemId].seller != msg.sender,
            "Can't buy your own NFT"
        );
        require(idToMarketItem[itemId].sold == false, "Item already sold");

        // AGORA FEES
        uint256 _fee = (price * saleFee) / 10000;
        totalFees += _fee;
        // CREATOR FEES
        uint256 _creatorFee = (price * creatorFee[nftContract]) / 10000;
        creatorRoyalties[creatorAddress[nftContract]] += _creatorFee;
        // PAY THE REST TO THE SELLER
        (bool success, ) = idToMarketItem[itemId].seller.call{
            value: (price - (_fee + _creatorFee))
        }("");
        require(success, "Pay Seller Failed");
        // UPDATE THE VOLUME OF THE COLLECTION
        contractVolume[nftContract] += msg.value;
        // TRANSFER THE NFT TO THE BUYER
        IERC721(nftContract).safeTransferFrom(
            address(this),
            msg.sender,
            tokenId
        );
        // SET THE OWNER OF THE ITEM TO BE THE BUYER
        idToMarketItem[itemId].owner = payable(msg.sender);
        // SET THE ITEM TO BE SOLD
        idToMarketItem[itemId].sold = true;
        // INCREASE THE NUMBER OF ITEMS SOLD
        _itemsSold.increment();

        emit MarketItemSale(
            itemId,
            nftContract,
            tokenId,
            idToMarketItem[itemId].seller,
            msg.sender,
            price
        );
    }

    function fetchMarketItem(uint256 itemId)
        public
        view
        returns (MarketItem memory)
    {
        MarketItem memory item = idToMarketItem[itemId];
        return item;
    }

    function delistMarketItem(address _nftContract, uint256 _itemId)
        external
        nonReentrant
        isAuthorized(_nftContract)
    {
        uint256 tokenId = idToMarketItem[_itemId].tokenId;
        require(
            idToMarketItem[_itemId].seller == msg.sender,
            "Only the seller can delist."
        );
        // SEND BACK THE NFT TO THE SELLER
        IERC721(_nftContract).safeTransferFrom(
            address(this),
            msg.sender,
            tokenId
        );
        idToMarketItem[_itemId].owner = payable(msg.sender);

        emit MarketItemDelist(_itemId, _nftContract, msg.sender);
    }

    function fetchMarketItems() public view returns (MarketItem[] memory) {
        uint256 itemCount = _itemIds.current();
        uint256 unsoldItemCount = _itemIds.current() - _itemsSold.current();
        uint256 currentIndex = 0;

        MarketItem[] memory items = new MarketItem[](unsoldItemCount);
        for (uint256 i = 0; i < itemCount; i++) {
            if (idToMarketItem[i + 1].owner == address(0)) {
                uint256 currentId = idToMarketItem[i + 1].itemId;
                MarketItem storage currentItem = idToMarketItem[currentId];
                items[currentIndex] = currentItem;
                currentIndex += 1;
            }
        }

        return items;
    }

    function fetchAllMarketItems() public view returns (MarketItem[] memory) {
        uint256 itemCount = _itemIds.current();
        uint256 currentIndex = 0;

        MarketItem[] memory items = new MarketItem[](itemCount);
        for (uint256 i = 0; i < itemCount; i++) {
            if (idToMarketItem[i + 1].owner != idToMarketItem[i + 1].seller) {
                uint256 currentId = idToMarketItem[i + 1].itemId;
                MarketItem storage currentItem = idToMarketItem[currentId];
                items[currentIndex] = currentItem;
                currentIndex += 1;
            }
        }

        return items;
    }

    function fetchMarketItems(address _nftContract)
        public
        view
        returns (MarketItem[] memory)
    {
        uint256 itemCount = _itemIds.current();
        uint256 unsoldItemCount = _itemIds.current() - _itemsSold.current();
        uint256 currentIndex = 0;

        MarketItem[] memory items = new MarketItem[](unsoldItemCount);
        for (uint256 i = 0; i < itemCount; i++) {
            if (
                idToMarketItem[i + 1].owner == address(0) &&
                idToMarketItem[i + 1].nftContract == _nftContract
            ) {
                uint256 currentId = idToMarketItem[i + 1].itemId;
                MarketItem storage currentItem = idToMarketItem[currentId];
                items[currentIndex] = currentItem;
                currentIndex += 1;
            }
        }

        return items;
    }

    /* Returns NFTs a user has sold */
    function fetchMyNFTsSold() public view returns (MarketItem[] memory) {
        uint256 totalItemCount = _itemIds.current();
        uint256 itemCount = 0;
        uint256 currentIndex = 0;

        for (uint256 i = 0; i < totalItemCount; i++) {
            if (
                idToMarketItem[i + 1].seller == msg.sender &&
                idToMarketItem[i + 1].owner != msg.sender &&
                idToMarketItem[i + 1].owner != address(0)
            ) {
                itemCount += 1;
            }
        }

        MarketItem[] memory items = new MarketItem[](itemCount);
        for (uint256 i = 0; i < totalItemCount; i++) {
            // SELLER IS CALLER + OWNER IS NOT SELLER + OWNER IS NOT 0x0 (NFT SOLD)
            if (
                idToMarketItem[i + 1].seller == msg.sender &&
                idToMarketItem[i + 1].owner != msg.sender &&
                idToMarketItem[i + 1].owner != address(0)
            ) {
                uint256 currentId = idToMarketItem[i + 1].itemId;
                MarketItem storage currentItem = idToMarketItem[currentId];
                items[currentIndex] = currentItem;
                currentIndex += 1;
            }
        }

        return items;
    }

    /* Returns NFTs a user has purchase */
    function fetchMyNFTs() public view returns (MarketItem[] memory) {
        uint256 totalItemCount = _itemIds.current();
        uint256 itemCount = 0;
        uint256 currentIndex = 0;

        for (uint256 i = 0; i < totalItemCount; i++) {
            if (idToMarketItem[i + 1].owner == msg.sender) {
                itemCount += 1;
            }
        }

        MarketItem[] memory items = new MarketItem[](itemCount);
        for (uint256 i = 0; i < totalItemCount; i++) {
            if (idToMarketItem[i + 1].owner == msg.sender) {
                uint256 currentId = idToMarketItem[i + 1].itemId;
                MarketItem storage currentItem = idToMarketItem[currentId];
                items[currentIndex] = currentItem;
                currentIndex += 1;
            }
        }

        return items;
    }

    /* Return NFTs a user has on sale */
    function fetchMyNFTsOnSale() public view returns (MarketItem[] memory) {
        uint256 totalItemCount = _itemIds.current();
        uint256 itemCount = 0;
        uint256 currentIndex = 0;

        for (uint256 i = 0; i < totalItemCount; i++) {
            if (
                idToMarketItem[i + 1].owner == address(0) &&
                idToMarketItem[i + 1].seller == msg.sender
            ) {
                itemCount += 1;
            }
        }

        MarketItem[] memory items = new MarketItem[](itemCount);
        for (uint256 i = 0; i < totalItemCount; i++) {
            if (
                idToMarketItem[i + 1].owner == address(0) &&
                idToMarketItem[i + 1].seller == msg.sender
            ) {
                uint256 currentId = idToMarketItem[i + 1].itemId;
                MarketItem storage currentItem = idToMarketItem[currentId];
                items[currentIndex] = currentItem;
                currentIndex += 1;
            }
        }

        return items;
    }

    function withdrawRoyalties(address _nftContract) public payable nonReentrant {
        require(
            msg.sender == creatorAddress[_nftContract],
            "Only the creator of the collection can withdraw the royalties."
        );
        (bool success, ) = creatorAddress[_nftContract].call{
            value: creatorRoyalties[creatorAddress[_nftContract]]
        }("");
        require(success, "WithdrawRoyalties Failed");
        
        creatorRoyalties[creatorAddress[_nftContract]] = 0;

        emit WithdrawRoyalties(
            _nftContract,
            msg.sender,
            creatorRoyalties[creatorAddress[_nftContract]]
        );
    }

    function withdrawFees() public payable nonReentrant onlyOwner {
        (bool success, ) = payable(msg.sender).call{value: totalFees}("");
        require(success);
        
        totalFees = 0;
    }
}

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"itemId","type":"uint256"},{"indexed":true,"internalType":"address","name":"nftContract","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"address","name":"seller","type":"address"},{"indexed":false,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"price","type":"uint256"},{"indexed":false,"internalType":"bool","name":"sold","type":"bool"}],"name":"MarketItemCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"itemId","type":"uint256"},{"indexed":true,"internalType":"address","name":"nftContract","type":"address"},{"indexed":false,"internalType":"address","name":"seller","type":"address"}],"name":"MarketItemDelist","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"itemId","type":"uint256"},{"indexed":true,"internalType":"address","name":"nftContract","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"address","name":"seller","type":"address"},{"indexed":false,"internalType":"address","name":"newOwner","type":"address"},{"indexed":false,"internalType":"uint256","name":"price","type":"uint256"}],"name":"MarketItemSale","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":"nftContract","type":"address"},{"indexed":false,"internalType":"address","name":"creator","type":"address"},{"indexed":false,"internalType":"uint256","name":"royalties","type":"uint256"}],"name":"WithdrawRoyalties","type":"event"},{"inputs":[{"internalType":"address","name":"_nftContract","type":"address"},{"internalType":"uint256","name":"_creatorFee","type":"uint256"},{"internalType":"address","name":"_creatorAddress","type":"address"}],"name":"addCollection","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"nftContract","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"price","type":"uint256"}],"name":"createMarketItem","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"nftContract","type":"address"},{"internalType":"uint256","name":"itemId","type":"uint256"}],"name":"createMarketSale","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_nftContract","type":"address"},{"internalType":"uint256","name":"_itemId","type":"uint256"}],"name":"delistMarketItem","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"fetchAllMarketItems","outputs":[{"components":[{"internalType":"uint256","name":"itemId","type":"uint256"},{"internalType":"address","name":"nftContract","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address payable","name":"seller","type":"address"},{"internalType":"address payable","name":"owner","type":"address"},{"internalType":"uint256","name":"price","type":"uint256"},{"internalType":"bool","name":"sold","type":"bool"}],"internalType":"struct NFTMarket.MarketItem[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"itemId","type":"uint256"}],"name":"fetchMarketItem","outputs":[{"components":[{"internalType":"uint256","name":"itemId","type":"uint256"},{"internalType":"address","name":"nftContract","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address payable","name":"seller","type":"address"},{"internalType":"address payable","name":"owner","type":"address"},{"internalType":"uint256","name":"price","type":"uint256"},{"internalType":"bool","name":"sold","type":"bool"}],"internalType":"struct NFTMarket.MarketItem","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"fetchMarketItems","outputs":[{"components":[{"internalType":"uint256","name":"itemId","type":"uint256"},{"internalType":"address","name":"nftContract","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address payable","name":"seller","type":"address"},{"internalType":"address payable","name":"owner","type":"address"},{"internalType":"uint256","name":"price","type":"uint256"},{"internalType":"bool","name":"sold","type":"bool"}],"internalType":"struct NFTMarket.MarketItem[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_nftContract","type":"address"}],"name":"fetchMarketItems","outputs":[{"components":[{"internalType":"uint256","name":"itemId","type":"uint256"},{"internalType":"address","name":"nftContract","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address payable","name":"seller","type":"address"},{"internalType":"address payable","name":"owner","type":"address"},{"internalType":"uint256","name":"price","type":"uint256"},{"internalType":"bool","name":"sold","type":"bool"}],"internalType":"struct NFTMarket.MarketItem[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"fetchMyNFTs","outputs":[{"components":[{"internalType":"uint256","name":"itemId","type":"uint256"},{"internalType":"address","name":"nftContract","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address payable","name":"seller","type":"address"},{"internalType":"address payable","name":"owner","type":"address"},{"internalType":"uint256","name":"price","type":"uint256"},{"internalType":"bool","name":"sold","type":"bool"}],"internalType":"struct NFTMarket.MarketItem[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"fetchMyNFTsOnSale","outputs":[{"components":[{"internalType":"uint256","name":"itemId","type":"uint256"},{"internalType":"address","name":"nftContract","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address payable","name":"seller","type":"address"},{"internalType":"address payable","name":"owner","type":"address"},{"internalType":"uint256","name":"price","type":"uint256"},{"internalType":"bool","name":"sold","type":"bool"}],"internalType":"struct NFTMarket.MarketItem[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"fetchMyNFTsSold","outputs":[{"components":[{"internalType":"uint256","name":"itemId","type":"uint256"},{"internalType":"address","name":"nftContract","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address payable","name":"seller","type":"address"},{"internalType":"address payable","name":"owner","type":"address"},{"internalType":"uint256","name":"price","type":"uint256"},{"internalType":"bool","name":"sold","type":"bool"}],"internalType":"struct NFTMarket.MarketItem[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_nftContract","type":"address"}],"name":"getContractVolume","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_nftContract","type":"address"}],"name":"getCreatorFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getNumberItemsSold","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_nftContract","type":"address"}],"name":"isContractAuthorized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"saleFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_fee","type":"uint256"}],"name":"setSaleFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawFees","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_nftContract","type":"address"}],"name":"withdrawRoyalties","outputs":[],"stateMutability":"payable","type":"function"}]

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

41151:13384:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48116:710;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43993:170;;;;;;;;;;-1:-1:-1;43993:170:0;;;;;:::i;:::-;-1:-1:-1;;;;;44122:33:0;44093:4;44122:33;;;:19;:33;;;;;;;;;43993:170;;;;1823:14:1;;1816:22;1798:41;;1786:2;1771:18;43993:170:0;1658:187:1;44171:207:0;;;;;;;;;;-1:-1:-1;44171:207:0;;;;;:::i;:::-;-1:-1:-1;;;44171:207:0;;;;;;;;;;-1:-1:-1;;;;;;3287:33:1;;;3269:52;;3257:2;3242:18;44171:207:0;3125:202:1;41416:28:0;;;;;;;;;;;;;;;;;;;3478:25:1;;;3466:2;3451:18;41416:28:0;3332:177:1;49489:864:0;;;;;;;;;;-1:-1:-1;49489:864:0;;;;;:::i;:::-;;:::i;51698:842::-;;;;;;;;;;;;;:::i;47243:201::-;;;;;;;;;;-1:-1:-1;47243:201:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;54325:207::-;;;:::i;:::-;;47452:656;;;;;;;;;;-1:-1:-1;47452:656:0;;;;;:::i;:::-;;:::i;44414:924::-;;;;;;:::i;:::-;;:::i;50401:1245::-;;;;;;;;;;;;;:::i;52590:1038::-;;;;;;;;;;;;;:::i;43363:165::-;;;;;;;;;;-1:-1:-1;43363:165:0;;;;;:::i;:::-;-1:-1:-1;;;;;43492:28:0;43460:7;43492:28;;;:14;:28;;;;;;;43363:165;39033:94;;;;;;;;;;;;;:::i;38382:87::-;;;;;;;;;;-1:-1:-1;38455:6:0;;38382:87;;-1:-1:-1;;;;;38455:6:0;;;4692:51:1;;4680:2;4665:18;38382:87:0;4546:203:1;43536:125:0;;;;;;;;;;-1:-1:-1;43536:125:0;;;;;:::i;:::-;-1:-1:-1;;;;;43629:24:0;43602:7;43629:24;;;:10;:24;;;;;;;43536:125;53636:681;;;;;;:::i;:::-;;:::i;43075:166::-;;;;;;;;;;-1:-1:-1;43075:166:0;;;;;:::i;:::-;;:::i;45366:1869::-;;;;;;:::i;:::-;;:::i;43669:316::-;;;;;;;;;;-1:-1:-1;43669:316:0;;;;;:::i;:::-;;:::i;43249:106::-;;;;;;;;;;;;;:::i;48834:647::-;;;;;;;;;;;;;:::i;39282:192::-;;;;;;;;;;-1:-1:-1;39282:192:0;;;;;:::i;:::-;;:::i;48116:710::-;48165:19;48197:17;48217:18;:8;40571:14;;40479:114;48217:18;48197:38;;48246:23;48293:20;:10;40571:14;;40479:114;48293:20;48272:8;40571:14;48272:41;;;;:::i;:::-;48246:67;;48324:20;48361:25;48406:15;48389:33;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;48361:61;;48438:9;48433:361;48457:9;48453:1;:13;48433:361;;;48531:1;48492:14;48531:1;48507:5;:1;48511;48507:5;:::i;:::-;48492:21;;;;;;;;;;;-1:-1:-1;48492:21:0;:27;;;-1:-1:-1;;;;;48492:27:0;:41;48488:295;;;48554:17;48574:14;48554:17;48589:5;:1;48593;48589:5;:::i;:::-;48574:21;;;;;;;;;;;;;;-1:-1:-1;48574:21:0;;;:28;48654:25;;;:14;:25;;;;;;48698:33;;;;;;;;;;;;;;;-1:-1:-1;;;;;48698:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:19;;48574:28;;-1:-1:-1;48698:5:0;;48704:12;;48698:19;;;;;;:::i;:::-;;;;;;;;;;:33;48750:17;48766:1;48750:17;;:::i;:::-;;;48535:248;;48488:295;48468:3;;;;:::i;:::-;;;;48433:361;;;-1:-1:-1;48813:5:0;48116:710;-1:-1:-1;;;;48116:710:0:o;49489:864::-;49585:19;49622:17;49642:18;:8;40571:14;;40479:114;49642:18;49622:38;;49671:23;49718:20;:10;40571:14;;40479:114;49718:20;49697:8;40571:14;49697:41;;;;:::i;:::-;49671:67;;49749:20;49786:25;49831:15;49814:33;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;49786:61;;49863:9;49858:463;49882:9;49878:1;:13;49858:463;;;49974:1;49935:14;49974:1;49950:5;:1;49954;49950:5;:::i;:::-;49935:21;;;;;;;;;;;-1:-1:-1;49935:21:0;:27;;;-1:-1:-1;;;;;49935:27:0;:41;:111;;;;-1:-1:-1;;;;;;49997:49:0;;:14;:21;50012:5;:1;50016;50012:5;:::i;:::-;49997:21;;;;;;;;;;;-1:-1:-1;49997:21:0;:33;;;-1:-1:-1;;;;;49997:33:0;:49;49935:111;49913:397;;;50081:17;50101:14;50081:17;50116:5;:1;50120;50116:5;:::i;:::-;50101:21;;;;;;;;;;;;;;-1:-1:-1;50101:21:0;;;:28;50181:25;;;:14;:25;;;;;;50225:33;;;;;;;;;;;;;;;-1:-1:-1;;;;;50225:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:19;;50101:28;;-1:-1:-1;50225:5:0;;50231:12;;50225:19;;;;;;:::i;:::-;;;;;;;;;;:33;50277:17;50293:1;50277:17;;:::i;:::-;;;50062:248;;49913:397;49893:3;;;;:::i;:::-;;;;49858:463;;;-1:-1:-1;50340:5:0;49489:864;-1:-1:-1;;;;;49489:864:0:o;51698:842::-;51742:19;51774:22;51799:18;:8;40571:14;;40479:114;51799:18;51774:43;;51828:17;51860:20;51902:9;51897:167;51921:14;51917:1;:18;51897:167;;;51992:10;51961:14;:21;51976:5;:1;51980;51976:5;:::i;:::-;51961:21;;;;;;;;;;;-1:-1:-1;51961:21:0;:27;;;-1:-1:-1;;;;;51961:27:0;:41;51957:96;;;52023:14;52036:1;52023:14;;:::i;:::-;;;51957:96;51937:3;;;;:::i;:::-;;;;51897:167;;;;52076:25;52121:9;52104:27;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;52076:55;;52147:9;52142:366;52166:14;52162:1;:18;52142:366;;;52237:10;52206:14;:21;52221:5;:1;52225;52221:5;:::i;:::-;52206:21;;;;;;;;;;;-1:-1:-1;52206:21:0;:27;;;-1:-1:-1;;;;;52206:27:0;:41;52202:295;;;52268:17;52288:14;52268:17;52303:5;:1;52307;52303:5;:::i;:::-;52288:21;;;;;;;;;;;;;;-1:-1:-1;52288:21:0;;;:28;52368:25;;;:14;:25;;;;;;52412:33;;;;;;;;;;;;;;;-1:-1:-1;;;;;52412:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:19;;52288:28;;-1:-1:-1;52412:5:0;;52418:12;;52412:19;;;;;;:::i;:::-;;;;;;;;;;:33;52464:17;52480:1;52464:17;;:::i;:::-;;;52249:248;;52202:295;52182:3;;;;:::i;:::-;;;;52142:366;;47243:201;47332:17;;:::i;:::-;-1:-1:-1;47367:22:0;47392;;;:14;:22;;;;;;;;;47367:47;;;;;;;;;;;;;;;-1:-1:-1;;;;;47367:47:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47243:201::o;54325:207::-;1747:1;2343:7;;:19;;2335:63;;;;-1:-1:-1;;;2335:63:0;;;;;;;:::i;:::-;;;;;;;;;1747:1;2476:7;:18;38455:6;;-1:-1:-1;;;;;38455:6:0;21871:10;38602:23:::1;38594:68;;;;-1:-1:-1::0;;;38594:68:0::1;;;;;;;:::i;:::-;54449:9:::2;::::0;54417:46:::2;::::0;54399:12:::2;::::0;54425:10:::2;::::0;54399:12;54417:46;54399:12;54417:46;54449:9;54425:10;54417:46:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54398:65;;;54482:7;54474:16;;;::::0;::::2;;-1:-1:-1::0;54523:1:0::2;54511:9;:13:::0;;;1703:1;2655:22;;54325:207::o;47452:656::-;1747:1;2343:7;;:19;;2335:63;;;;-1:-1:-1;;;2335:63:0;;;;;;;:::i;:::-;1747:1;2476:7;:18;;;-1:-1:-1;;;;;43013:33:0;::::1;::::0;;:19:::1;:33;::::0;;;;;47579:12;;43013:33:::1;;43005:42;;;::::0;::::1;;47609:15:::2;47627:23:::0;;;:14:::2;:23;::::0;;;;:31:::2;::::0;::::2;::::0;47691:30:::2;::::0;;::::2;::::0;-1:-1:-1;;;;;47691:30:0::2;47725:10;47691:44;47669:121;;;::::0;-1:-1:-1;;;47669:121:0;;6887:2:1;47669:121:0::2;::::0;::::2;6869:21:1::0;6926:2;6906:18;;;6899:30;6965:29;6945:18;;;6938:57;7012:18;;47669:121:0::2;6685:351:1::0;47669:121:0::2;47845:124;::::0;-1:-1:-1;;;47845:124:0;;-1:-1:-1;;;;;47845:38:0;::::2;::::0;::::2;::::0;:124:::2;::::0;47906:4:::2;::::0;47926:10:::2;::::0;47951:7;;47845:124:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;-1:-1:-1::0;;;47980:23:0::2;::::0;;;:14:::2;:23;::::0;;;;;;;;:29:::2;;:51:::0;;-1:-1:-1;;;;;;47980:51:0::2;48020:10;47980:51:::0;;::::2;::::0;;;48049;;4692::1;;;-1:-1:-1;;;;;48049:51:0;::::2;::::0;-1:-1:-1;47980:23:0;;48049:51:::2;::::0;4665:18:1;48049:51:0::2;;;;;;;-1:-1:-1::0;;1703:1:0;2655:7;:22;-1:-1:-1;;47452:656:0:o;44414:924::-;1747:1;2343:7;;:19;;2335:63;;;;-1:-1:-1;;;2335:63:0;;;;;;;:::i;:::-;1747:1;2476:7;:18;;;-1:-1:-1;;;;;43013:33:0;::::1;::::0;;:19:::1;:33;::::0;;;;;44568:11;;43013:33:::1;;43005:42;;;::::0;::::1;;44608:1:::2;44600:5;:9;44592:50;;;::::0;-1:-1:-1;;;44592:50:0;;7623:2:1;44592:50:0::2;::::0;::::2;7605:21:1::0;7662:2;7642:18;;;7635:30;7701;7681:18;;;7674:58;7749:18;;44592:50:0::2;7421:352:1::0;44592:50:0::2;44655:20;:8;40690:19:::0;;40708:1;40690:19;;;40601:127;44655:20:::2;44686:14;44703:18;:8;40571:14:::0;;40479:114;44703:18:::2;44759:230;::::0;;::::2;::::0;::::2;::::0;;;;;-1:-1:-1;;;;;44759:230:0;;::::2;;::::0;;::::2;::::0;;;;;;;;;44861:10:::2;44759:230:::0;;;;;;-1:-1:-1;44759:230:0;;;;;;;;;;;;;;;;;;44734:22;;;:14:::2;:22:::0;;;;;;;:255;;;;;;44759:230;44734:255;::::2;::::0;;-1:-1:-1;;;;;;44734:255:0;;::::2;::::0;;::::2;::::0;;;::::2;::::0;;;;::::2;::::0;::::2;::::0;;;::::2;::::0;::::2;::::0;;;::::2;::::0;;::::2;::::0;;;::::2;::::0;;;;::::2;::::0;;::::2;::::0;;;;::::2;::::0;;;::::2;;::::0;;;;;::::2;::::0;::::2;::::0;;;::::2;::::0;;::::2;::::0;;-1:-1:-1;;44734:255:0::2;::::0;::::2;;::::0;;;::::2;::::0;;;45002:123;;-1:-1:-1;;;45002:123:0;;44759:230;;-1:-1:-1;44759:230:0;;45002:37:::2;::::0;:123:::2;::::0;44861:10;45087:4:::2;::::0;44759:230;;45002:123:::2;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;-1:-1:-1::0;;45143:187:0::2;::::0;;45244:10:::2;8041:34:1::0;;45277:1:0::2;8106:2:1::0;8091:18;;8084:43;;;8143:18;;;8136:34;;;8201:2;8186:18;;8179:50;45143:187:0;;45222:7;;-1:-1:-1;;;;;;45143:187:0;::::2;::::0;-1:-1:-1;45175:6:0;;45143:187:::2;::::0;;;;;7990:3:1;45143:187:0;;::::2;-1:-1:-1::0;;1703:1:0;2655:7;:22;-1:-1:-1;;;44414:924:0:o;50401:1245::-;50449:19;50481:22;50506:18;:8;40571:14;;40479:114;50506:18;50481:43;;50535:17;50567:20;50609:9;50604:324;50628:14;50624:1;:18;50604:324;;;50718:10;50686:14;:21;50701:5;:1;50705;50701:5;:::i;:::-;50686:21;;;;;;;;;;;-1:-1:-1;50686:21:0;:28;;;-1:-1:-1;;;;;50686:28:0;:42;:104;;;;-1:-1:-1;50780:10:0;50749:14;:21;50764:5;:1;50768;50764:5;:::i;:::-;50749:21;;;;;;;;;;;-1:-1:-1;50749:21:0;:27;;;-1:-1:-1;;;;;50749:27:0;:41;;50686:104;:166;;;;-1:-1:-1;50850:1:0;50811:14;50850:1;50826:5;:1;50830;50826:5;:::i;:::-;50811:21;;;;;;;;;;;-1:-1:-1;50811:21:0;:27;;;-1:-1:-1;;;;;50811:27:0;:41;;50686:166;50664:253;;;50887:14;50900:1;50887:14;;:::i;:::-;;;50664:253;50644:3;;;;:::i;:::-;;;;50604:324;;;;50940:25;50985:9;50968:27;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;50940:55;;51011:9;51006:608;51030:14;51026:1;:18;51006:608;;;51205:10;51173:14;:21;51188:5;:1;51192;51188:5;:::i;:::-;51173:21;;;;;;;;;;;-1:-1:-1;51173:21:0;:28;;;-1:-1:-1;;;;;51173:28:0;:42;:104;;;;-1:-1:-1;51267:10:0;51236:14;:21;51251:5;:1;51255;51251:5;:::i;:::-;51236:21;;;;;;;;;;;-1:-1:-1;51236:21:0;:27;;;-1:-1:-1;;;;;51236:27:0;:41;;51173:104;:166;;;;-1:-1:-1;51337:1:0;51298:14;51337:1;51313:5;:1;51317;51313:5;:::i;:::-;51298:21;;;;;;;;;;;-1:-1:-1;51298:21:0;:27;;;-1:-1:-1;;;;;51298:27:0;:41;;51173:166;51151:452;;;51374:17;51394:14;51374:17;51409:5;:1;51413;51409:5;:::i;:::-;51394:21;;;;;;;;;;;;;;-1:-1:-1;51394:21:0;;;:28;51474:25;;;:14;:25;;;;;;51518:33;;;;;;;;;;;;;;;-1:-1:-1;;;;;51518:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:19;;51394:28;;-1:-1:-1;51518:5:0;;51524:12;;51518:19;;;;;;:::i;:::-;;;;;;;;;;:33;51570:17;51586:1;51570:17;;:::i;:::-;;;51355:248;;51151:452;51046:3;;;;:::i;:::-;;;;51006:608;;52590:1038;52640:19;52672:22;52697:18;:8;40571:14;;40479:114;52697:18;52672:43;;52726:17;52758:20;52800:9;52795:262;52819:14;52815:1;:18;52795:262;;;52916:1;52877:14;52916:1;52892:5;:1;52896;52892:5;:::i;:::-;52877:21;;;;;;;;;;;-1:-1:-1;52877:21:0;:27;;;-1:-1:-1;;;;;52877:27:0;:41;:104;;;;-1:-1:-1;52971:10:0;52939:14;:21;52954:5;:1;52958;52954:5;:::i;:::-;52939:21;;;;;;;;;;;-1:-1:-1;52939:21:0;:28;;;-1:-1:-1;;;;;52939:28:0;:42;52877:104;52855:191;;;53016:14;53029:1;53016:14;;:::i;:::-;;;52855:191;52835:3;;;;:::i;:::-;;;;52795:262;;;;53069:25;53114:9;53097:27;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;53069:55;;53140:9;53135:461;53159:14;53155:1;:18;53135:461;;;53256:1;53217:14;53256:1;53232:5;:1;53236;53232:5;:::i;:::-;53217:21;;;;;;;;;;;-1:-1:-1;53217:21:0;:27;;;-1:-1:-1;;;;;53217:27:0;:41;:104;;;;-1:-1:-1;53311:10:0;53279:14;:21;53294:5;:1;53298;53294:5;:::i;:::-;53279:21;;;;;;;;;;;-1:-1:-1;53279:21:0;:28;;;-1:-1:-1;;;;;53279:28:0;:42;53217:104;53195:390;;;53356:17;53376:14;53356:17;53391:5;:1;53395;53391:5;:::i;:::-;53376:21;;;;;;;;;;;;;;-1:-1:-1;53376:21:0;;;:28;53456:25;;;:14;:25;;;;;;53500:33;;;;;;;;;;;;;;;-1:-1:-1;;;;;53500:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:19;;53376:28;;-1:-1:-1;53500:5:0;;53506:12;;53500:19;;;;;;:::i;:::-;;;;;;;;;;:33;53552:17;53568:1;53552:17;;:::i;:::-;;;53337:248;;53195:390;53175:3;;;;:::i;:::-;;;;53135:461;;39033:94;38455:6;;-1:-1:-1;;;;;38455:6:0;21871:10;38602:23;38594:68;;;;-1:-1:-1;;;38594:68:0;;;;;;;:::i;:::-;39098:21:::1;39116:1;39098:9;:21::i;:::-;39033:94::o:0;53636:681::-;1747:1;2343:7;;:19;;2335:63;;;;-1:-1:-1;;;2335:63:0;;;;;;;:::i;:::-;1747:1;2476:7;:18;;;-1:-1:-1;;;;;53760:28:0;;::::1;::::0;;:14:::1;:28;::::0;;;;;;::::1;53746:10;:42;53724:154;;;::::0;-1:-1:-1;;;53724:154:0;;8442:2:1;53724:154:0::1;::::0;::::1;8424:21:1::0;8481:2;8461:18;;;8454:30;8520:34;8500:18;;;8493:62;8591:32;8571:18;;;8564:60;8641:19;;53724:154:0::1;8240:426:1::0;53724:154:0::1;-1:-1:-1::0;;;;;53908:28:0;;::::1;53890:12;53908:28:::0;;;:14:::1;:28;::::0;;;;;;;;;;::::1;53963:46:::0;;;:16:::1;:46:::0;;;;;;;53908:116;;53890:12;;53908:28;;53890:12;53908:116;53890:12;53908:116;53963:46;53908:28;:116:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53889:135;;;54043:7;54035:44;;;::::0;-1:-1:-1;;;54035:44:0;;8873:2:1;54035:44:0::1;::::0;::::1;8855:21:1::0;8912:2;8892:18;;;8885:30;8951:26;8931:18;;;8924:54;8995:18;;54035:44:0::1;8671:348:1::0;54035:44:0::1;-1:-1:-1::0;;;;;54117:28:0;;::::1;54149:1;54117:28:::0;;;:14:::1;:28;::::0;;;;;;;;;;::::1;54100:46:::0;;:16:::1;:46:::0;;;;;:50;;;54269:28;;;::::1;54252:46:::0;;;;;;;54168:141;;54227:10:::1;9198:51:1::0;;9265:18;;;9258:34;54117:28:0;;54168:141:::1;::::0;9171:18:1;54168:141:0::1;;;;;;;-1:-1:-1::0;;1703:1:0;2655:7;:22;53636:681::o;43075:166::-;38455:6;;-1:-1:-1;;;;;38455:6:0;21871:10;38602:23;38594:68;;;;-1:-1:-1;;;38594:68:0;;;;;;;:::i;:::-;43153:12:::1;;43145:4;:20;;43137:71;;;::::0;-1:-1:-1;;;43137:71:0;;9505:2:1;43137:71:0::1;::::0;::::1;9487:21:1::0;9544:2;9524:18;;;9517:30;9583:34;9563:18;;;9556:62;-1:-1:-1;;;9634:18:1;;;9627:36;9680:19;;43137:71:0::1;9303:402:1::0;43137:71:0::1;43219:7;:14:::0;43075:166::o;45366:1869::-;1747:1;2343:7;;:19;;2335:63;;;;-1:-1:-1;;;2335:63:0;;;;;;;:::i;:::-;1747:1;2476:7;:18;;;-1:-1:-1;;;;;43013:33:0;::::1;::::0;;:19:::1;:33;::::0;;;;;45506:11;;43013:33:::1;;43005:42;;;::::0;::::1;;45535:13:::2;45551:22:::0;;;:14:::2;:22;::::0;;;;:28:::2;::::0;::::2;::::0;45608:30:::2;::::0;;::::2;::::0;45671:9:::2;:18:::0;::::2;45649:132;;;::::0;;-1:-1:-1;;;45649:132:0;;9912:2:1;45649:132:0::2;::::0;::::2;9894:21:1::0;9931:18;;;9924:30;;;;9990:34;9970:18;;;9963:62;10061:34;10041:18;;;10034:62;10113:19;;45649:132:0::2;9710:428:1::0;45649:132:0::2;45814:22;::::0;;;:14:::2;:22;::::0;;;;:29:::2;;::::0;-1:-1:-1;;;;;45814:29:0::2;45847:10;45814:43;;45792:115;;;::::0;-1:-1:-1;;;45792:115:0;;10345:2:1;45792:115:0::2;::::0;::::2;10327:21:1::0;10384:2;10364:18;;;10357:30;-1:-1:-1;;;10403:18:1;;;10396:52;10465:18;;45792:115:0::2;10143:346:1::0;45792:115:0::2;45926:22;::::0;;;:14:::2;:22;::::0;;;;:27:::2;;::::0;::::2;;:36;45918:66;;;::::0;-1:-1:-1;;;45918:66:0;;10696:2:1;45918:66:0::2;::::0;::::2;10678:21:1::0;10735:2;10715:18;;;10708:30;-1:-1:-1;;;10754:18:1;;;10747:47;10811:18;;45918:66:0::2;10494:341:1::0;45918:66:0::2;46020:12;46055:5;46044:7;;46036:5;:15;;;;:::i;:::-;46035:25;;;;:::i;:::-;46020:40;;46084:4;46071:9;;:17;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;;;;;;46155:23:0;::::2;46124:19;46155:23:::0;;;:10:::2;:23;::::0;;;;;46182:5:::2;::::0;46147:31:::2;::::0;:5;:31:::2;:::i;:::-;46146:41;;;;:::i;:::-;-1:-1:-1::0;;;;;46215:27:0;;::::2;46198:45;46215:27:::0;;;:14:::2;:27;::::0;;;;;;;;;;::::2;46198:45:::0;;:16:::2;:45:::0;;;;;:60;;46124:63;;-1:-1:-1;46124:63:0;;46198:45;;;:60:::2;::::0;46124:63;;46198:60:::2;:::i;:::-;::::0;;;-1:-1:-1;;46309:12:0::2;46327:22:::0;;;:14:::2;:22;::::0;;;;:29:::2;;::::0;-1:-1:-1;;;;;46327:29:0::2;46393:18;46400:11:::0;46393:4;:18:::2;:::i;:::-;46384:28;::::0;:5;:28:::2;:::i;:::-;46327:101;::::0;::::2;::::0;;;;;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46308:120;;;46447:7;46439:37;;;::::0;-1:-1:-1;;;46439:37:0;;11437:2:1;46439:37:0::2;::::0;::::2;11419:21:1::0;11476:2;11456:18;;;11449:30;-1:-1:-1;;;11495:18:1;;;11488:47;11552:18;;46439:37:0::2;11235:341:1::0;46439:37:0::2;-1:-1:-1::0;;;;;46535:27:0;::::2;;::::0;;;:14:::2;:27;::::0;;;;:40;;46566:9:::2;::::0;46535:27;:40:::2;::::0;46566:9;;46535:40:::2;:::i;:::-;::::0;;;-1:-1:-1;;46628:123:0::2;::::0;-1:-1:-1;;;46628:123:0;;-1:-1:-1;;;;;46628:37:0;::::2;::::0;::::2;::::0;:123:::2;::::0;46688:4:::2;::::0;46708:10:::2;::::0;46733:7;;46628:123:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;-1:-1:-1::0;;;46816:22:0::2;::::0;;;:14:::2;:22;::::0;;;;:28:::2;::::0;::::2;:50:::0;;-1:-1:-1;;;;;;46816:50:0::2;46855:10;46816:50;::::0;;46913:27:::2;;:34:::0;;-1:-1:-1;;46913:34:0::2;46816:50:::0;46913:34:::2;::::0;;-1:-1:-1;47004:22:0::2;:10;40690:19:::0;;40708:1;40690:19;;;40601:127;47004:22:::2;47142;::::0;;;:14:::2;:22;::::0;;;;;;:29:::2;;::::0;47044:183;;47120:7;;-1:-1:-1;;;;;47044:183:0;;::::2;::::0;47073:6;;47044:183:::2;::::0;::::2;::::0;47142:29;::::2;::::0;47186:10:::2;::::0;47211:5;;47044:183:::2;:::i;:::-;;;;;;;;-1:-1:-1::0;;1703:1:0;2655:7;:22;-1:-1:-1;;;;;;45366:1869:0:o;43669:316::-;38455:6;;-1:-1:-1;;;;;38455:6:0;21871:10;38602:23;38594:68;;;;-1:-1:-1;;;38594:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;43822:33:0;;::::1;;::::0;;;:19:::1;:33;::::0;;;;;;;:40;;-1:-1:-1;;43822:40:0::1;43858:4;43822:40;::::0;;43873:10:::1;:24:::0;;;;;:38;;;;43922:14:::1;:28:::0;;;;;;:55;;;;;::::1;-1:-1:-1::0;;;;;;43922:55:0;;::::1;;::::0;;43669:316::o;43249:106::-;43300:7;43327:20;:10;40571:14;;40479:114;43327:20;43320:27;;43249:106;:::o;48834:647::-;48886:19;48918:17;48938:18;:8;40571:14;;40479:114;48938:18;48918:38;;48967:20;49004:25;49049:9;49032:27;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;49004:55;;49075:9;49070:379;49094:9;49090:1;:13;49070:379;;;49160:14;:21;49175:5;:1;49179;49175:5;:::i;:::-;49160:21;;;;;;;;;;;-1:-1:-1;49160:21:0;;;:28;;;-1:-1:-1;;;;;49160:28:0;;49129:14;;49144:5;:1;49160:28;49144:5;:::i;:::-;49129:21;;;;;;;;;;;-1:-1:-1;49129:21:0;:27;;;-1:-1:-1;;;;;49129:27:0;:59;49125:313;;49209:17;49229:14;49209:17;49244:5;:1;49248;49244:5;:::i;:::-;49229:21;;;;;;;;;;;;;;-1:-1:-1;49229:21:0;;;:28;49309:25;;;:14;:25;;;;;;49353:33;;;;;;;;;;;;;;;-1:-1:-1;;;;;49353:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:19;;49229:28;;-1:-1:-1;49353:5:0;;49359:12;;49353:19;;;;;;:::i;:::-;;;;;;;;;;:33;49405:17;49421:1;49405:17;;:::i;:::-;;;49190:248;;49125:313;49105:3;;;;:::i;:::-;;;;49070:379;;;-1:-1:-1;49468:5:0;48834:647;-1:-1:-1;;;48834:647:0:o;39282:192::-;38455:6;;-1:-1:-1;;;;;38455:6:0;21871:10;38602:23;38594:68;;;;-1:-1:-1;;;38594:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;39371:22:0;::::1;39363:73;;;::::0;-1:-1:-1;;;39363:73:0;;12171:2:1;39363:73:0::1;::::0;::::1;12153:21:1::0;12210:2;12190:18;;;12183:30;12249:34;12229:18;;;12222:62;-1:-1:-1;;;12300:18:1;;;12293:36;12346:19;;39363:73:0::1;11969:402:1::0;39363:73:0::1;39447:19;39457:8;39447:9;:19::i;:::-;39282:192:::0;:::o;39482:173::-;39557:6;;;-1:-1:-1;;;;;39574:17:0;;;-1:-1:-1;;;;;;39574:17:0;;;;;;;39607:40;;39557:6;;;39574:17;39557:6;;39607:40;;39538:16;;39607:40;39527:128;39482:173;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;14:553:1:-;96:5;90:12;85:3;78:25;149:4;142:5;138:16;132:23;191:1;187;182:3;178:11;174:19;243:2;229:12;225:21;218:4;213:3;209:14;202:45;296:4;289:5;285:16;279:23;272:4;267:3;263:14;256:47;364:2;356:4;349:5;345:16;339:23;335:32;328:4;323:3;319:14;312:56;429:2;421:4;414:5;410:16;404:23;400:32;393:4;388:3;384:14;377:56;;;482:4;475:5;471:16;465:23;458:4;453:3;449:14;442:47;552:4;545:5;541:16;535:23;528:31;521:39;514:4;509:3;505:14;498:63;14:553;;:::o;572:712::-;799:2;851:21;;;921:13;;824:18;;;943:22;;;770:4;;799:2;1022:15;;;;996:2;981:18;;;770:4;1065:193;1079:6;1076:1;1073:13;1065:193;;;1128:48;1172:3;1163:6;1157:13;1128:48;:::i;:::-;1233:15;;;;1205:4;1196:14;;;;;1101:1;1094:9;1065:193;;;-1:-1:-1;1275:3:1;;572:712;-1:-1:-1;;;;;;572:712:1:o;1289:173::-;1357:20;;-1:-1:-1;;;;;1406:31:1;;1396:42;;1386:70;;1452:1;1449;1442:12;1386:70;1289:173;;;:::o;1467:186::-;1526:6;1579:2;1567:9;1558:7;1554:23;1550:32;1547:52;;;1595:1;1592;1585:12;1547:52;1618:29;1637:9;1618:29;:::i;:::-;1608:39;1467:186;-1:-1:-1;;;1467:186:1:o;1850:127::-;1911:10;1906:3;1902:20;1899:1;1892:31;1942:4;1939:1;1932:15;1966:4;1963:1;1956:15;1982:1138;2077:6;2085;2093;2101;2154:3;2142:9;2133:7;2129:23;2125:33;2122:53;;;2171:1;2168;2161:12;2122:53;2194:29;2213:9;2194:29;:::i;:::-;2184:39;;2242:38;2276:2;2265:9;2261:18;2242:38;:::i;:::-;2232:48;;2327:2;2316:9;2312:18;2299:32;2289:42;;2382:2;2371:9;2367:18;2354:32;2405:18;2446:2;2438:6;2435:14;2432:34;;;2462:1;2459;2452:12;2432:34;2500:6;2489:9;2485:22;2475:32;;2545:7;2538:4;2534:2;2530:13;2526:27;2516:55;;2567:1;2564;2557:12;2516:55;2603:2;2590:16;2625:2;2621;2618:10;2615:36;;;2631:18;;:::i;:::-;2706:2;2700:9;2674:2;2760:13;;-1:-1:-1;;2756:22:1;;;2780:2;2752:31;2748:40;2736:53;;;2804:18;;;2824:22;;;2801:46;2798:72;;;2850:18;;:::i;:::-;2890:10;2886:2;2879:22;2925:2;2917:6;2910:18;2965:7;2960:2;2955;2951;2947:11;2943:20;2940:33;2937:53;;;2986:1;2983;2976:12;2937:53;3042:2;3037;3033;3029:11;3024:2;3016:6;3012:15;2999:46;3087:1;3082:2;3077;3069:6;3065:15;3061:24;3054:35;3108:6;3098:16;;;;;;;1982:1138;;;;;;;:::o;3514:180::-;3573:6;3626:2;3614:9;3605:7;3601:23;3597:32;3594:52;;;3642:1;3639;3632:12;3594:52;-1:-1:-1;3665:23:1;;3514:180;-1:-1:-1;3514:180:1:o;3699:256::-;3889:3;3874:19;;3902:47;3878:9;3931:6;3902:47;:::i;:::-;3699:256;;;;:::o;3960:254::-;4028:6;4036;4089:2;4077:9;4068:7;4064:23;4060:32;4057:52;;;4105:1;4102;4095:12;4057:52;4128:29;4147:9;4128:29;:::i;:::-;4118:39;4204:2;4189:18;;;;4176:32;;-1:-1:-1;;;3960:254:1:o;4219:322::-;4296:6;4304;4312;4365:2;4353:9;4344:7;4340:23;4336:32;4333:52;;;4381:1;4378;4371:12;4333:52;4404:29;4423:9;4404:29;:::i;:::-;4394:39;4480:2;4465:18;;4452:32;;-1:-1:-1;4531:2:1;4516:18;;;4503:32;;4219:322;-1:-1:-1;;;4219:322:1:o;4754:328::-;4831:6;4839;4847;4900:2;4888:9;4879:7;4875:23;4871:32;4868:52;;;4916:1;4913;4906:12;4868:52;4939:29;4958:9;4939:29;:::i;:::-;4929:39;;5015:2;5004:9;5000:18;4987:32;4977:42;;5038:38;5072:2;5061:9;5057:18;5038:38;:::i;:::-;5028:48;;4754:328;;;;;:::o;5087:127::-;5148:10;5143:3;5139:20;5136:1;5129:31;5179:4;5176:1;5169:15;5203:4;5200:1;5193:15;5219:125;5259:4;5287:1;5284;5281:8;5278:34;;;5292:18;;:::i;:::-;-1:-1:-1;5329:9:1;;5219:125::o;5349:128::-;5389:3;5420:1;5416:6;5413:1;5410:13;5407:39;;;5426:18;;:::i;:::-;-1:-1:-1;5462:9:1;;5349:128::o;5482:127::-;5543:10;5538:3;5534:20;5531:1;5524:31;5574:4;5571:1;5564:15;5598:4;5595:1;5588:15;5614:135;5653:3;-1:-1:-1;;5674:17:1;;5671:43;;;5694:18;;:::i;:::-;-1:-1:-1;5741:1:1;5730:13;;5614:135::o;5754:355::-;5956:2;5938:21;;;5995:2;5975:18;;;5968:30;6034:33;6029:2;6014:18;;6007:61;6100:2;6085:18;;5754:355::o;6114:356::-;6316:2;6298:21;;;6335:18;;;6328:30;6394:34;6389:2;6374:18;;6367:62;6461:2;6446:18;;6114:356::o;7041:375::-;-1:-1:-1;;;;;7299:15:1;;;7281:34;;7351:15;;;;7346:2;7331:18;;7324:43;7398:2;7383:18;;7376:34;;;;7231:2;7216:18;;7041:375::o;10840:168::-;10880:7;10946:1;10942;10938:6;10934:14;10931:1;10928:21;10923:1;10916:9;10909:17;10905:45;10902:71;;;10953:18;;:::i;:::-;-1:-1:-1;10993:9:1;;10840:168::o;11013:217::-;11053:1;11079;11069:132;;11123:10;11118:3;11114:20;11111:1;11104:31;11158:4;11155:1;11148:15;11186:4;11183:1;11176:15;11069:132;-1:-1:-1;11215:9:1;;11013:217::o

3d8985bf1fde00cc0af4bdcc33f7e61eb466aded4cce8464e0759716a9762ef0