Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: UNLICENSED
pragma solidity =0.8.17;

import "./ERC721Rebased.sol";

/**
 * @dev DigiRose - Fully on-chain ERC721 NFT Contract
 *
 *          <= ERC721Rebased
 *          <= ERC721RoyaltyOwnable
 *          <= ERC721WithOperatorFilter
 *          <= ERC721Royalty
 *          <= ERC721Enumerable
 *          <= ERC721
 */
contract DigiRose is ERC721Rebased {
    uint256 private _DEAD_LINE = 1676458799;

    constructor(
        string memory name_,
        string memory symbol_,
        address dataURIContract_,
        address newOwner_
    )
        ERC721(name_, symbol_)
        ERC721Rebased(dataURIContract_)
        ERC721RoyaltyOwnable(newOwner_)
    {}

    function mint(address to_) public {
        require(block.timestamp < _DEAD_LINE, "DigiRose: minting is closed");
        require(_msgSender() != to_, "DigiRose: cannot mint to self");
        _mintNFT(to_);
    }

    function _mintNFT(address to_) internal {
        uint256 tokenId = totalSupply() + 1;

        _dna[tokenId] = keccak256(
            abi.encodePacked(
                tokenId,
                _msgSender(),
                block.difficulty,
                block.coinbase,
                blockhash(block.number - 1)
            )
        );

        _safeMint(to_, tokenId);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @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
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 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
            functionCallWithValue(
                target,
                data,
                0,
                "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"
        );
        (bool success, bytes memory returndata) = target.call{value: value}(
            data
        );
        return
            verifyCallResultFromTarget(
                target,
                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) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return
            verifyCallResultFromTarget(
                target,
                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) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return
            verifyCallResultFromTarget(
                target,
                success,
                returndata,
                errorMessage
            );
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or 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 {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(
        bytes memory returndata,
        string memory errorMessage
    ) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// SPDX-License-Identifier: MIT
// 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;
    }
}

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

import {OperatorFilterer} from "./OperatorFilterer.sol";

/**
 * @title  DefaultOperatorFilterer
 * @notice Inherits from OperatorFilterer and automatically subscribes to the default OpenSea subscription.
 */
abstract contract DefaultOperatorFilterer is OperatorFilterer {
    address constant DEFAULT_SUBSCRIPTION = address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);

    constructor() OperatorFilterer(DEFAULT_SUBSCRIPTION, true) {}
}

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

pragma solidity ^0.8.0;

import "./IERC165.sol";

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/ERC721.sol)

pragma solidity ^0.8.0;

import "./IERC721.sol";
import "./IERC721Receiver.sol";
import "./IERC721Metadata.sol";
import "./Address.sol";
import "./Context.sol";
import "./Strings.sol";
import "./ERC165.sol";

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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

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

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(
        uint256 tokenId
    ) public view virtual override returns (address) {
        address owner = _ownerOf(tokenId);
        require(owner != address(0), "ERC721: invalid token ID");
        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) {
        _requireMinted(tokenId);

        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 overridden 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 token owner or approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(
        uint256 tokenId
    ) public view virtual override returns (address) {
        _requireMinted(tokenId);

        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: caller is not token owner or 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: caller is not token owner or 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 the owner of the `tokenId`. Does NOT revert if token doesn't exist
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

    /**
     * @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 _ownerOf(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) {
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner ||
            isApprovedForAll(owner, spender) ||
            getApproved(tokenId) == 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, 1);

        // Check that tokenId was not minted by `_beforeTokenTransfer` hook
        require(!_exists(tokenId), "ERC721: token already minted");

        unchecked {
            // Will not overflow unless all 2**256 token ids are minted to the same owner.
            // Given that tokens are minted one by one, it is impossible in practice that
            // this ever happens. Might change if we allow batch minting.
            // The ERC fails to describe this case.
            _balances[to] += 1;
        }

        _owners[tokenId] = to;

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

        _afterTokenTransfer(address(0), to, tokenId, 1);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     * This is an internal function that does not check if the sender is authorized to operate on the token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

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

        // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook
        owner = ERC721.ownerOf(tokenId);

        // Clear approvals
        delete _tokenApprovals[tokenId];

        unchecked {
            // Cannot overflow, as that would require more tokens to be burned/transferred
            // out than the owner initially received through minting and transferring in.
            _balances[owner] -= 1;
        }
        delete _owners[tokenId];

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

        _afterTokenTransfer(owner, address(0), tokenId, 1);
    }

    /**
     * @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 from incorrect owner"
        );
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId, 1);

        // Check that tokenId was not transferred by `_beforeTokenTransfer` hook
        require(
            ERC721.ownerOf(tokenId) == from,
            "ERC721: transfer from incorrect owner"
        );

        // Clear approvals from the previous owner
        delete _tokenApprovals[tokenId];

        unchecked {
            // `_balances[from]` cannot overflow for the same reason as described in `_burn`:
            // `from`'s balance is the number of token held, which is at least one before the current
            // transfer.
            // `_balances[to]` could overflow in the conditions described in `_mint`. That would require
            // all 2**256 token ids to be minted, which in practice is impossible.
            _balances[from] -= 1;
            _balances[to] += 1;
        }
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId, 1);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits an {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 an {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 Reverts if the `tokenId` has not been minted yet.
     */
    function _requireMinted(uint256 tokenId) internal view virtual {
        require(_exists(tokenId), "ERC721: invalid token ID");
    }

    /**
     * @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 {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`.
     * - When `from` is zero, the tokens will be minted for `to`.
     * - When `to` is zero, ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 /* firstTokenId */,
        uint256 batchSize
    ) internal virtual {
        if (batchSize > 1) {
            if (from != address(0)) {
                _balances[from] -= batchSize;
            }
            if (to != address(0)) {
                _balances[to] += batchSize;
            }
        }
    }

    /**
     * @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
     * - When `from` is zero, the tokens were minted for `to`.
     * - When `to` is zero, ``from``'s tokens were burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 firstTokenId,
        uint256 batchSize
    ) internal virtual {}
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/extensions/ERC721Enumerable.sol)

pragma solidity ^0.8.0;

import "./ERC721.sol";
import "./IERC721Enumerable.sol";

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

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

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

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

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

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

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

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

    /**
     * @dev See {ERC721-_beforeTokenTransfer}.
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 firstTokenId,
        uint256 batchSize
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, firstTokenId, batchSize);

        if (batchSize > 1) {
            // Will only trigger during construction. Batch transferring (minting) is not available afterwards.
            revert("ERC721Enumerable: consecutive transfers not supported");
        }

        uint256 tokenId = firstTokenId;

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

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;

import "./IDataURI.sol";
import "./ERC721WithOperatorFilter.sol";

/**
 * @dev Rebased ERC721 Contract
 *
 *      ERC721Rebased
 *          <= ERC721WithOperatorFilter
 *          <= ERC721RoyaltyOwnable
 *          <= ERC721Royalty
 *          <= ERC721Enumerable
 *          <= ERC721
 */
abstract contract ERC721Rebased is ERC721WithOperatorFilter {
    IDataURI private _dataURIContract;

    mapping(uint256 => bytes32) internal _dna;

    constructor(address dataURIContract_) {
        _setDataURIContract(dataURIContract_);
    }

    function dataURIContract() public view returns (address) {
        return address(_dataURIContract);
    }

    function tokenURI(
        uint256 tokenId_
    ) public view virtual override returns (string memory) {
        _requireMinted(tokenId_);

        return _dataURIContract.tokenURI(tokenId_, _dna[tokenId_]);
    }

    function setDataURIContract(address dataURIContract_) public onlyOwner {
        _dataURIContract = IDataURI(dataURIContract_);
    }

    function _setDataURIContract(address dataURIContract_) internal {
        _dataURIContract = IDataURI(dataURIContract_);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (token/common/ERC2981.sol)

pragma solidity ^0.8.0;

import "./IERC2981.sol";
import "./ERC721Enumerable.sol";

/**
 * @dev ERC721Royalty
 *          <= ERC721Enumerable
 *          <= ERC721
 */
abstract contract ERC721Royalty is ERC721Enumerable, IERC2981 {
    struct RoyaltyInfo {
        address receiver;
        uint96 royaltyFraction;
    }

    RoyaltyInfo private _defaultRoyaltyInfo;
    mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo;

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

    /**
     * @inheritdoc IERC2981
     */
    function royaltyInfo(
        uint256 _tokenId,
        uint256 _salePrice
    ) public view virtual override returns (address, uint256) {
        RoyaltyInfo memory royalty = _tokenRoyaltyInfo[_tokenId];

        if (royalty.receiver == address(0)) {
            royalty = _defaultRoyaltyInfo;
        }

        uint256 royaltyAmount = (_salePrice * royalty.royaltyFraction) /
            _feeDenominator();

        return (royalty.receiver, royaltyAmount);
    }

    /**
     * @dev The denominator with which to interpret the fee set in {_setTokenRoyalty} and {_setDefaultRoyalty} as a
     * fraction of the sale price. Defaults to 10000 so fees are expressed in basis points, but may be customized by an
     * override.
     */
    function _feeDenominator() internal pure virtual returns (uint96) {
        return 10000;
    }

    /**
     * @dev Sets the royalty information that all ids in this contract will default to.
     *
     * Requirements:
     *
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setDefaultRoyalty(
        address receiver,
        uint96 feeNumerator
    ) internal virtual {
        require(
            feeNumerator <= _feeDenominator(),
            "ERC2981: royalty fee will exceed salePrice"
        );
        require(receiver != address(0), "ERC2981: invalid receiver");

        _defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Removes default royalty information.
     */
    function _deleteDefaultRoyalty() internal virtual {
        delete _defaultRoyaltyInfo;
    }

    /**
     * @dev Sets the royalty information for a specific token id, overriding the global default.
     *
     * Requirements:
     *
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setTokenRoyalty(
        uint256 tokenId,
        address receiver,
        uint96 feeNumerator
    ) internal virtual {
        require(
            feeNumerator <= _feeDenominator(),
            "ERC2981: royalty fee will exceed salePrice"
        );
        require(receiver != address(0), "ERC2981: Invalid parameters");

        _tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Resets royalty information for the token id back to the global default.
     */
    function _resetTokenRoyalty(uint256 tokenId) internal virtual {
        delete _tokenRoyaltyInfo[tokenId];
    }

    /**
     * @dev See {ERC721-_burn}. This override additionally clears the royalty information for the token.
     */
    function _burn(uint256 tokenId) internal virtual override {
        super._burn(tokenId);
        _resetTokenRoyalty(tokenId);
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;

import "./Ownable.sol";
import "./ERC721Royalty.sol";

/**
 * @dev Ownable Royalty ERC721 Contract
 *
 *      ERC721RoyaltyOwnable
 *          <= ERC721Royalty
 *          <= ERC721Enumerable
 *          <= ERC721
 */
abstract contract ERC721RoyaltyOwnable is ERC721Royalty, Ownable {
    constructor(address newOwner_) {
        transferOwnership(newOwner_);
    }

    /**
     * @dev See {IERC2981-_setDefaultRoyalty}.
     */
    function setDefaultRoyalty(
        address receiver_,
        uint96 feeNumerator_
    ) external onlyOwner {
        _setDefaultRoyalty(receiver_, feeNumerator_);
    }

    /**
     * @dev See {IERC2981-_deleteDefaultRoyalty}.
     */
    function deleteDefaultRoyalty() external onlyOwner {
        _deleteDefaultRoyalty();
    }

    /**
     * @dev See {IERC2981-_setTokenRoyalty}.
     */
    function setTokenRoyalty(
        uint256 tokenId_,
        address receiver_,
        uint96 feeNumerator_
    ) external onlyOwner {
        _setTokenRoyalty(tokenId_, receiver_, feeNumerator_);
    }

    /**
     * @dev See {IERC2981-_resetTokenRoyalty}.
     */
    function resetTokenRoyalty(uint256 tokenId_) external onlyOwner {
        _resetTokenRoyalty(tokenId_);
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;

import "./DefaultOperatorFilterer.sol";
import "./ERC721RoyaltyOwnable.sol";

/**
 * @dev ERC721 with Default OperatorFilter provided by OpenSEA
 *
 *      ERC721WithOperatorFilter
 *          <= ERC721RoyaltyOwnable
 *          <= ERC721Royalty
 *          <= ERC721Enumerable
 *          <= ERC721
 */
abstract contract ERC721WithOperatorFilter is
    DefaultOperatorFilterer,
    ERC721RoyaltyOwnable
{
    function setApprovalForAll(
        address operator,
        bool approved
    ) public override(ERC721, IERC721) onlyAllowedOperatorApproval(operator) {
        super.setApprovalForAll(operator, approved);
    }

    function approve(
        address operator,
        uint256 tokenId
    ) public override(ERC721, IERC721) onlyAllowedOperatorApproval(operator) {
        super.approve(operator, tokenId);
    }

    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public override(ERC721, IERC721) onlyAllowedOperator(from) {
        super.transferFrom(from, to, tokenId);
    }

    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public override(ERC721, IERC721) onlyAllowedOperator(from) {
        super.safeTransferFrom(from, to, tokenId);
    }

    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) public override(ERC721, IERC721) onlyAllowedOperator(from) {
        super.safeTransferFrom(from, to, tokenId, data);
    }
}

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

interface IDataURI {
    function tokenURI(
        uint256 i_,
        bytes32 b_
    ) external view returns (string memory);
}

// SPDX-License-Identifier: MIT
// 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);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (interfaces/IERC2981.sol)

pragma solidity ^0.8.0;

import "./IERC165.sol";

/**
 * @dev Interface for the NFT Royalty Standard.
 *
 * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal
 * support for royalty payments across all NFT marketplaces and ecosystem participants.
 *
 * _Available since v4.5._
 */
interface IERC2981 is IERC165 {
    /**
     * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of
     * exchange. The royalty amount is denominated and should be paid in that same unit of exchange.
     */
    function royaltyInfo(
        uint256 tokenId,
        uint256 salePrice
    ) external view returns (address receiver, uint256 royaltyAmount);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

import "./IERC165.sol";

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

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

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

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

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

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

    /**
     * @dev 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 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: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * 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 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 the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(
        uint256 tokenId
    ) external view returns (address operator);

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.0;

import "./IERC721.sol";

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;

import "./IERC721.sol";

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (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 `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

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

interface IOperatorFilterRegistry {
    function isOperatorAllowed(
        address registrant,
        address operator
    ) external view returns (bool);

    function register(address registrant) external;

    function registerAndSubscribe(
        address registrant,
        address subscription
    ) external;

    function registerAndCopyEntries(
        address registrant,
        address registrantToCopy
    ) external;

    function unregister(address addr) external;

    function updateOperator(
        address registrant,
        address operator,
        bool filtered
    ) external;

    function updateOperators(
        address registrant,
        address[] calldata operators,
        bool filtered
    ) external;

    function updateCodeHash(
        address registrant,
        bytes32 codehash,
        bool filtered
    ) external;

    function updateCodeHashes(
        address registrant,
        bytes32[] calldata codeHashes,
        bool filtered
    ) external;

    function subscribe(
        address registrant,
        address registrantToSubscribe
    ) external;

    function unsubscribe(address registrant, bool copyExistingEntries) external;

    function subscriptionOf(address addr) external returns (address registrant);

    function subscribers(
        address registrant
    ) external returns (address[] memory);

    function subscriberAt(
        address registrant,
        uint256 index
    ) external returns (address);

    function copyEntriesOf(
        address registrant,
        address registrantToCopy
    ) external;

    function isOperatorFiltered(
        address registrant,
        address operator
    ) external returns (bool);

    function isCodeHashOfFiltered(
        address registrant,
        address operatorWithCode
    ) external returns (bool);

    function isCodeHashFiltered(
        address registrant,
        bytes32 codeHash
    ) external returns (bool);

    function filteredOperators(
        address addr
    ) external returns (address[] memory);

    function filteredCodeHashes(
        address addr
    ) external returns (bytes32[] memory);

    function filteredOperatorAt(
        address registrant,
        uint256 index
    ) external returns (address);

    function filteredCodeHashAt(
        address registrant,
        uint256 index
    ) external returns (bytes32);

    function isRegistered(address addr) external returns (bool);

    function codeHashOf(address addr) external returns (bytes32);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

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

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

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

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

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

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import {IOperatorFilterRegistry} from "./IOperatorFilterRegistry.sol";

/**
 * @title  OperatorFilterer
 * @notice Abstract contract whose constructor automatically registers and optionally subscribes to or copies another
 *         registrant's entries in the OperatorFilterRegistry.
 * @dev    This smart contract is meant to be inherited by token contracts so they can use the following:
 *         - `onlyAllowedOperator` modifier for `transferFrom` and `safeTransferFrom` methods.
 *         - `onlyAllowedOperatorApproval` modifier for `approve` and `setApprovalForAll` methods.
 */
abstract contract OperatorFilterer {
    error OperatorNotAllowed(address operator);

    IOperatorFilterRegistry public constant OPERATOR_FILTER_REGISTRY =
        IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);

    constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
        // If an inheriting token contract is deployed to a network without the registry deployed, the modifier
        // will not revert, but the contract will need to be registered with the registry once it is deployed in
        // order for the modifier to filter addresses.
        if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
            if (subscribe) {
                OPERATOR_FILTER_REGISTRY.registerAndSubscribe(
                    address(this),
                    subscriptionOrRegistrantToCopy
                );
            } else {
                if (subscriptionOrRegistrantToCopy != address(0)) {
                    OPERATOR_FILTER_REGISTRY.registerAndCopyEntries(
                        address(this),
                        subscriptionOrRegistrantToCopy
                    );
                } else {
                    OPERATOR_FILTER_REGISTRY.register(address(this));
                }
            }
        }
    }

    modifier onlyAllowedOperator(address from) virtual {
        // Allow spending tokens from addresses with balance
        // Note that this still allows listings and marketplaces with escrow to transfer tokens if transferred
        // from an EOA.
        if (from != msg.sender) {
            _checkFilterOperator(msg.sender);
        }
        _;
    }

    modifier onlyAllowedOperatorApproval(address operator) virtual {
        _checkFilterOperator(operator);
        _;
    }

    function _checkFilterOperator(address operator) internal view virtual {
        // Check registry code length to facilitate testing in environments without a deployed registry.
        if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
            if (
                !OPERATOR_FILTER_REGISTRY.isOperatorAllowed(
                    address(this),
                    operator
                )
            ) {
                revert OperatorNotAllowed(operator);
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "./Context.sol";

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

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

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

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

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

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

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

pragma solidity ^0.8.0;

import "./Math.sol";

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @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] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"address","name":"dataURIContract_","type":"address"},{"internalType":"address","name":"newOwner_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"OPERATOR_FILTER_REGISTRY","outputs":[{"internalType":"contract IOperatorFilterRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","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":"dataURIContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deleteDefaultRoyalty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to_","type":"address"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId_","type":"uint256"}],"name":"resetTokenRoyalty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"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":"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":"address","name":"dataURIContract_","type":"address"}],"name":"setDataURIContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"receiver_","type":"address"},{"internalType":"uint96","name":"feeNumerator_","type":"uint96"}],"name":"setDefaultRoyalty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId_","type":"uint256"},{"internalType":"address","name":"receiver_","type":"address"},{"internalType":"uint96","name":"feeNumerator_","type":"uint96"}],"name":"setTokenRoyalty","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":"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"}]

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

000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000073344bffcf8f7dba1013df8988425594e47b83ae0000000000000000000000004001ea5570b68e6a13f666c9a7e36d0d8ae68d59000000000000000000000000000000000000000000000000000000000000000844696769526f7365000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000564526f7365000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name_ (string): DigiRose
Arg [1] : symbol_ (string): dRose
Arg [2] : dataURIContract_ (address): 0x73344bffCF8f7DBa1013Df8988425594E47B83aE
Arg [3] : newOwner_ (address): 0x4001Ea5570b68E6a13f666c9A7E36d0D8aE68d59

-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 00000000000000000000000073344bffcf8f7dba1013df8988425594e47b83ae
Arg [3] : 0000000000000000000000004001ea5570b68e6a13f666c9a7e36d0d8ae68d59
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000008
Arg [5] : 44696769526f7365000000000000000000000000000000000000000000000000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [7] : 64526f7365000000000000000000000000000000000000000000000000000000

349:952:3:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;604:261:8;;;;;;:::i;:::-;;:::i;:::-;;;565:14:23;;558:22;540:41;;528:2;513:18;604:261:8;;;;;;;;498:170:9;;;;;;:::i;:::-;;:::i;:::-;;2482:98:5;;;:::i;:::-;;;;;;;:::i;4004:181::-;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;2322:32:23;;;2304:51;;2292:2;2277:18;4004:181:5;2158:203:23;693:194:10;;;;;;:::i;:::-;;:::i;1723:111:6:-;1810:10;:17;1723:111;;;2771:25:23;;;2759:2;2744:18;1723:111:6;2625:177:23;893:208:10;;;;;;:::i;:::-;;:::i;915:466:8:-;;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;3585:32:23;;;3567:51;;3649:2;3634:18;;3627:34;;;;3540:18;915:466:8;3393:274:23;1343:309:6;;;;;;:::i;:::-;;:::i;737:142:20:-;;836:42;737:142;;1107:216:10;;;;;;:::i;:::-;;:::i;1906:278:6:-;;;;;;:::i;:::-;;:::i;898:202:9:-;;;;;;:::i;:::-;;:::i;2187:233:5:-;;;;;;:::i;:::-;;:::i;698:213:3:-;;;;;;:::i;:::-;;:::i;1878:252:5:-;;;;;;:::i;:::-;;:::i;1846:101:21:-;;;:::i;1169:109:9:-;;;;;;:::i;:::-;;:::i;1216:85:21:-;1288:6;;-1:-1:-1;;;;;1288:6:21;1216:85;;2644:102:5;;;:::i;474:213:10:-;;;;;;:::i;:::-;;:::i;740:91:9:-;;;:::i;938:133:7:-;;;;;;:::i;:::-;;:::i;1329:249:10:-;;;;;;:::i;:::-;;:::i;719:213:7:-;;;;;;:::i;:::-;;:::i;607:106::-;689:16;;-1:-1:-1;;;;;689:16:7;607:106;;4493:184:5;;;;;;:::i;:::-;-1:-1:-1;;;;;4635:25:5;;;4612:4;4635:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;4493:184;2096:232:21;;;;;;:::i;:::-;;:::i;604:261:8:-;730:4;-1:-1:-1;;;;;;765:41:8;;-1:-1:-1;;;765:41:8;;:93;;;822:36;846:11;822:23;:36::i;:::-;746:112;604:261;-1:-1:-1;;604:261:8:o;498:170:9:-;1109:13:21;:11;:13::i;:::-;617:44:9::1;636:9;647:13;617:18;:44::i;:::-;498:170:::0;;:::o;2482:98:5:-;2536:13;2568:5;2561:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2482:98;:::o;4004:181::-;4094:7;4113:23;4128:7;4113:14;:23::i;:::-;-1:-1:-1;4154:24:5;;;;:15;:24;;;;;;-1:-1:-1;;;;;4154:24:5;;4004:181::o;693:194:10:-;828:8;2355:30:20;2376:8;2355:20;:30::i;:::-;848:32:10::1;862:8;872:7;848:13;:32::i;:::-;693:194:::0;;;:::o;893:208::-;1041:4;-1:-1:-1;;;;;2182:18:20;;2190:10;2182:18;2178:81;;2216:32;2237:10;2216:20;:32::i;:::-;1057:37:10::1;1076:4;1082:2;1086:7;1057:18;:37::i;:::-;893:208:::0;;;;:::o;915:466:8:-;1034:7;1091:27;;;:17;:27;;;;;;;;1062:56;;;;;;;;;-1:-1:-1;;;;;1062:56:8;;;;;-1:-1:-1;;;1062:56:8;;;-1:-1:-1;;;;;1062:56:8;;;;;;;;1034:7;;1129:90;;-1:-1:-1;1179:29:8;;;;;;;;;1189:19;1179:29;-1:-1:-1;;;;;1179:29:8;;;;-1:-1:-1;;;1179:29:8;;-1:-1:-1;;;;;1179:29:8;;;;;1129:90;1267:23;;;;1229:21;;1739:5;;1254:36;;-1:-1:-1;;;;;1254:36:8;:10;:36;:::i;:::-;1253:70;;;;:::i;:::-;1342:16;;;;;-1:-1:-1;915:466:8;;-1:-1:-1;;;;915:466:8:o;1343:309:6:-;1462:7;1510:23;1527:5;1510:16;:23::i;:::-;1502:5;:31;1481:121;;;;-1:-1:-1;;;1481:121:6;;7752:2:23;1481:121:6;;;7734:21:23;7791:2;7771:18;;;7764:30;7830:34;7810:18;;;7803:62;-1:-1:-1;;;7881:18:23;;;7874:41;7932:19;;1481:121:6;;;;;;;;;-1:-1:-1;;;;;;1619:19:6;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;1343:309::o;1107:216:10:-;1259:4;-1:-1:-1;;;;;2182:18:20;;2190:10;2182:18;2178:81;;2216:32;2237:10;2216:20;:32::i;:::-;1275:41:10::1;1298:4;1304:2;1308:7;1275:22;:41::i;1906:278:6:-:0;1995:7;2043:30;1810:10;:17;;1723:111;2043:30;2035:5;:38;2014:129;;;;-1:-1:-1;;;2014:129:6;;8164:2:23;2014:129:6;;;8146:21:23;8203:2;8183:18;;;8176:30;8242:34;8222:18;;;8215:62;-1:-1:-1;;;8293:18:23;;;8286:42;8345:19;;2014:129:6;7962:408:23;2014:129:6;2160:10;2171:5;2160:17;;;;;;;;:::i;:::-;;;;;;;;;2153:24;;1906:278;;;:::o;898:202:9:-;1109:13:21;:11;:13::i;:::-;1041:52:9::1;1058:8;1068:9;1079:13;1041:16;:52::i;2187:233:5:-:0;2273:7;7159:16;;;:7;:16;;;;;;-1:-1:-1;;;;;7159:16:5;;2335:56;;;;-1:-1:-1;;;2335:56:5;;8709:2:23;2335:56:5;;;8691:21:23;8748:2;8728:18;;;8721:30;-1:-1:-1;;;8767:18:23;;;8760:54;8831:18;;2335:56:5;8507:348:23;698:213:3;768:10;;750:15;:28;742:68;;;;-1:-1:-1;;;742:68:3;;9062:2:23;742:68:3;;;9044:21:23;9101:2;9081:18;;;9074:30;9140:29;9120:18;;;9113:57;9187:18;;742:68:3;8860:351:23;742:68:3;-1:-1:-1;;;;;828:19:3;;719:10:1;828:19:3;820:61;;;;-1:-1:-1;;;820:61:3;;9418:2:23;820:61:3;;;9400:21:23;9457:2;9437:18;;;9430:30;9496:31;9476:18;;;9469:59;9545:18;;820:61:3;9216:353:23;820:61:3;891:13;900:3;891:8;:13::i;:::-;698:213;:::o;1878:252:5:-;1964:7;-1:-1:-1;;;;;2004:19:5;;1983:107;;;;-1:-1:-1;;;1983:107:5;;9776:2:23;1983:107:5;;;9758:21:23;9815:2;9795:18;;;9788:30;9854:34;9834:18;;;9827:62;-1:-1:-1;;;9905:18:23;;;9898:39;9954:19;;1983:107:5;9574:405:23;1983:107:5;-1:-1:-1;;;;;;2107:16:5;;;;;:9;:16;;;;;;;1878:252::o;1846:101:21:-;1109:13;:11;:13::i;:::-;1910:30:::1;1937:1;1910:18;:30::i;:::-;1846:101::o:0;1169:109:9:-;1109:13:21;:11;:13::i;:::-;3429:26:8;;;;:17;:26;;;;;3422:33;698:213:3:o;2644:102:5:-;2700:13;2732:7;2725:14;;;;;:::i;474:213:10:-;617:8;2355:30:20;2376:8;2355:20;:30::i;:::-;637:43:10::1;661:8;671;637:23;:43::i;740:91:9:-:0;1109:13:21;:11;:13::i;:::-;801:23:9::1;2533:19:8::0;;2526:26;2466:93;938:133:7;1109:13:21;:11;:13::i;:::-;1019:16:7::1;:45:::0;;-1:-1:-1;;;;;;1019:45:7::1;-1:-1:-1::0;;;;;1019:45:7;;;::::1;::::0;;;::::1;::::0;;938:133::o;1329:249:10:-;1508:4;-1:-1:-1;;;;;2182:18:20;;2190:10;2182:18;2178:81;;2216:32;2237:10;2216:20;:32::i;:::-;1524:47:10::1;1547:4;1553:2;1557:7;1566:4;1524:22;:47::i;:::-;1329:249:::0;;;;;:::o;719:213:7:-;807:13;832:24;847:8;832:14;:24::i;:::-;874:16;;;910:14;;;:4;:14;;;;;;;;874:51;;-1:-1:-1;;;874:51:7;;;;;10158:25:23;;;10199:18;;;10192:34;;;;-1:-1:-1;;;;;874:16:7;;;;:25;;10131:18:23;;874:51:7;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;874:51:7;;;;;;;;;;;;:::i;2096:232:21:-;1109:13;:11;:13::i;:::-;-1:-1:-1;;;;;2197:22:21;::::1;2176:107;;;::::0;-1:-1:-1;;;2176:107:21;;11092:2:23;2176:107:21::1;::::0;::::1;11074:21:23::0;11131:2;11111:18;;;11104:30;11170:34;11150:18;;;11143:62;-1:-1:-1;;;11221:18:23;;;11214:36;11267:19;;2176:107:21::1;10890:402:23::0;2176:107:21::1;2293:28;2312:8;2293:18;:28::i;1004:260:6:-:0;1120:4;-1:-1:-1;;;;;;1155:50:6;;-1:-1:-1;;;1155:50:6;;:102;;;1221:36;1245:11;1221:23;:36::i;1374:130:21:-;1288:6;;-1:-1:-1;;;;;1288:6:21;719:10:1;1437:23:21;1429:68;;;;-1:-1:-1;;;1429:68:21;;11499:2:23;1429:68:21;;;11481:21:23;;;11518:18;;;11511:30;11577:34;11557:18;;;11550:62;11629:18;;1429:68:21;11297:356:23;2012:383:8;1739:5;-1:-1:-1;;;;;2149:33:8;;;;2128:122;;;;-1:-1:-1;;;2128:122:8;;;;;;;:::i;:::-;-1:-1:-1;;;;;2268:22:8;;2260:60;;;;-1:-1:-1;;;2260:60:8;;12271:2:23;2260:60:8;;;12253:21:23;12310:2;12290:18;;;12283:30;12349:27;12329:18;;;12322:55;12394:18;;2260:60:8;12069:349:23;2260:60:8;2353:35;;;;;;;;;-1:-1:-1;;;;;2353:35:8;;;;;;-1:-1:-1;;;;;2353:35:8;;;;;;;;;;-1:-1:-1;;;2331:57:8;;;;:19;:57;2012:383::o;13809:133:5:-;7550:4;7159:16;;;:7;:16;;;;;;-1:-1:-1;;;;;7159:16:5;13882:53;;;;-1:-1:-1;;;13882:53:5;;8709:2:23;13882:53:5;;;8691:21:23;8748:2;8728:18;;;8721:30;-1:-1:-1;;;8767:18:23;;;8760:54;8831:18;;13882:53:5;8507:348:23;2409:500:20;836:42;2598:45;:49;2594:309;;2685:125;;-1:-1:-1;;;2685:125:20;;2757:4;2685:125;;;12635:34:23;-1:-1:-1;;;;;12705:15:23;;12685:18;;;12678:43;836:42:20;;2685;;12570:18:23;;2685:125:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2663:230;;2850:28;;-1:-1:-1;;;2850:28:20;;-1:-1:-1;;;;;2322:32:23;;2850:28:20;;;2304:51:23;2277:18;;2850:28:20;2158:203:23;3537:406:5;3617:13;3633:23;3648:7;3633:14;:23::i;:::-;3617:39;;3680:5;-1:-1:-1;;;;;3674:11:5;:2;-1:-1:-1;;;;;3674:11:5;;3666:57;;;;-1:-1:-1;;;3666:57:5;;13184:2:23;3666:57:5;;;13166:21:23;13223:2;13203:18;;;13196:30;13262:34;13242:18;;;13235:62;-1:-1:-1;;;13313:18:23;;;13306:31;13354:19;;3666:57:5;12982:397:23;3666:57:5;719:10:1;-1:-1:-1;;;;;3755:21:5;;;;:62;;-1:-1:-1;3780:37:5;3797:5;719:10:1;4493:184:5;:::i;3780:37::-;3734:170;;;;-1:-1:-1;;;3734:170:5;;13586:2:23;3734:170:5;;;13568:21:23;13625:2;13605:18;;;13598:30;13664:34;13644:18;;;13637:62;13735:31;13715:18;;;13708:59;13784:19;;3734:170:5;13384:425:23;3734:170:5;3915:21;3924:2;3928:7;3915:8;:21::i;4739:360::-;4941:41;719:10:1;4974:7:5;4941:18;:41::i;:::-;4920:133;;;;-1:-1:-1;;;4920:133:5;;;;;;;:::i;:::-;5064:28;5074:4;5080:2;5084:7;5064:9;:28::i;5165:179::-;5298:39;5315:4;5321:2;5325:7;5298:39;;;;;;;;;;;;:16;:39::i;2829:415:8:-;1739:5;-1:-1:-1;;;;;2989:33:8;;;;2968:122;;;;-1:-1:-1;;;2968:122:8;;;;;;;:::i;:::-;-1:-1:-1;;;;;3108:22:8;;3100:62;;;;-1:-1:-1;;;3100:62:8;;14430:2:23;3100:62:8;;;14412:21:23;14469:2;14449:18;;;14442:30;14508:29;14488:18;;;14481:57;14555:18;;3100:62:8;14228:351:23;3100:62:8;3202:35;;;;;;;;-1:-1:-1;;;;;3202:35:8;;;;;-1:-1:-1;;;;;3202:35:8;;;;;;;;;;-1:-1:-1;3173:26:8;;;:17;:26;;;;;;:64;;;;;;;-1:-1:-1;;;3173:64:8;;;;;;2829:415::o;917:382:3:-;967:15;985:13;1810:10:6;:17;;1723:111;985:13:3;:17;;1001:1;985:17;:::i;:::-;967:35;-1:-1:-1;967:35:3;719:10:1;1141:16:3;1175:14;1217:16;1232:1;1217:12;:16;:::i;:::-;1052:196;;;;;;15104:19:23;;;;-1:-1:-1;;15211:2:23;15207:15;;;15203:24;;15189:12;;;15182:46;;;;15244:12;;;15237:28;;;;15299:15;;15295:24;15281:12;;;15274:46;1207:27:3;15336:13:23;;;15329:29;15374:13;;1052:196:3;;;-1:-1:-1;;1052:196:3;;;;;;;;;1029:229;;1052:196;1029:229;;;;1013:13;;;;:4;:13;;;;;:245;1269:23;1279:3;1018:7;1269:9;:23::i;2482:187:21:-;2574:6;;;-1:-1:-1;;;;;2590:17:21;;;-1:-1:-1;;;;;;2590:17:21;;;;;;;2622:40;;2574:6;;;2590:17;2574:6;;2622:40;;2555:16;;2622:40;2545:124;2482:187;:::o;4252:175:5:-;4368:52;719:10:1;4401:8:5;4411;4368:18;:52::i;5410:348::-;5591:41;719:10:1;5624:7:5;5591:18;:41::i;:::-;5570:133;;;;-1:-1:-1;;;5570:133:5;;;;;;;:::i;:::-;5713:38;5727:4;5733:2;5737:7;5746:4;5713:13;:38::i;1505:314::-;1621:4;-1:-1:-1;;;;;;1656:40:5;;-1:-1:-1;;;1656:40:5;;:104;;-1:-1:-1;;;;;;;1712:48:5;;-1:-1:-1;;;1712:48:5;1656:104;:156;;;-1:-1:-1;;;;;;;;;;951:40:4;;;1776:36:5;829:169:4;13111:171:5;13185:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;13185:29:5;-1:-1:-1;;;;;13185:29:5;;;;;;;;:24;;13238:23;13185:24;13238:14;:23::i;:::-;-1:-1:-1;;;;;13229:46:5;;;;;;;;;;;13111:171;;:::o;7769:307::-;7884:4;7900:13;7916:23;7931:7;7916:14;:23::i;:::-;7900:39;;7968:5;-1:-1:-1;;;;;7957:16:5;:7;-1:-1:-1;;;;;7957:16:5;;:64;;;-1:-1:-1;;;;;;4635:25:5;;;4612:4;4635:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;7989:32;7957:111;;;;8061:7;-1:-1:-1;;;;;8037:31:5;:20;8049:7;8037:11;:20::i;:::-;-1:-1:-1;;;;;8037:31:5;;7957:111;7949:120;7769:307;-1:-1:-1;;;;7769:307:5:o;11698:1301::-;11865:4;-1:-1:-1;;;;;11838:31:5;:23;11853:7;11838:14;:23::i;:::-;-1:-1:-1;;;;;11838:31:5;;11817:115;;;;-1:-1:-1;;;11817:115:5;;;;;;;:::i;:::-;-1:-1:-1;;;;;11950:16:5;;11942:65;;;;-1:-1:-1;;;11942:65:5;;16006:2:23;11942:65:5;;;15988:21:23;16045:2;16025:18;;;16018:30;16084:34;16064:18;;;16057:62;-1:-1:-1;;;16135:18:23;;;16128:34;16179:19;;11942:65:5;15804:400:23;11942:65:5;12018:42;12039:4;12045:2;12049:7;12058:1;12018:20;:42::i;:::-;12200:4;-1:-1:-1;;;;;12173:31:5;:23;12188:7;12173:14;:23::i;:::-;-1:-1:-1;;;;;12173:31:5;;12152:115;;;;-1:-1:-1;;;12152:115:5;;;;;;;:::i;:::-;12336:24;;;;:15;:24;;;;;;;;12329:31;;-1:-1:-1;;;;;;12329:31:5;;;;;;-1:-1:-1;;;;;12804:15:5;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;12804:20:5;;;12838:13;;;;;;;;;:18;;12329:31;12838:18;;;12876:16;;;:7;:16;;;;;;:21;;;;;;;;;;12913:27;;12352:7;;12913:27;;;693:194:10;;;:::o;8406:108:5:-;8481:26;8491:2;8495:7;8481:26;;;;;;;;;;;;:9;:26::i;13418:307::-;13568:8;-1:-1:-1;;;;;13559:17:5;:5;-1:-1:-1;;;;;13559:17:5;;13551:55;;;;-1:-1:-1;;;13551:55:5;;16411:2:23;13551:55:5;;;16393:21:23;16450:2;16430:18;;;16423:30;16489:27;16469:18;;;16462:55;16534:18;;13551:55:5;16209:349:23;13551:55:5;-1:-1:-1;;;;;13616:25:5;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;13616:46:5;;;;;;;;;;13677:41;;540::23;;;13677::5;;513:18:23;13677:41:5;;;;;;;13418:307;;;:::o;6619:339::-;6769:28;6779:4;6785:2;6789:7;6769:9;:28::i;:::-;6828:47;6851:4;6857:2;6861:7;6870:4;6828:22;:47::i;:::-;6807:144;;;;-1:-1:-1;;;6807:144:5;;;;;;;:::i;2253:890:6:-;2424:61;2451:4;2457:2;2461:12;2475:9;2424:26;:61::i;:::-;2512:1;2500:9;:13;2496:219;;;2641:63;;-1:-1:-1;;;2641:63:6;;17184:2:23;2641:63:6;;;17166:21:23;17223:2;17203:18;;;17196:30;17262:34;17242:18;;;17235:62;-1:-1:-1;;;17313:18:23;;;17306:51;17374:19;;2641:63:6;16982:417:23;2496:219:6;2743:12;-1:-1:-1;;;;;2770:18:6;;2766:183;;2804:40;2836:7;3952:10;:17;;3925:24;;;;:15;:24;;;;;:44;;;3979:24;;;;;;;;;;;;3849:161;2804:40;2766:183;;;2873:2;-1:-1:-1;;;;;2865:10:6;:4;-1:-1:-1;;;;;2865:10:6;;2861:88;;2891:47;2924:4;2930:7;2891:32;:47::i;:::-;-1:-1:-1;;;;;2962:16:6;;2958:179;;2994:45;3031:7;2994:36;:45::i;:::-;2958:179;;;3066:4;-1:-1:-1;;;;;3060:10:6;:2;-1:-1:-1;;;;;3060:10:6;;3056:81;;3086:40;3114:2;3118:7;3086:27;:40::i;8735:309:5:-;8859:18;8865:2;8869:7;8859:5;:18::i;:::-;8908:53;8939:1;8943:2;8947:7;8956:4;8908:22;:53::i;:::-;8887:150;;;;-1:-1:-1;;;8887:150:5;;;;;;;:::i;14494:1003::-;14643:4;-1:-1:-1;;;;;14663:13:5;;1465:19:0;:23;14659:832:5;;14714:169;;-1:-1:-1;;;14714:169:5;;-1:-1:-1;;;;;14714:36:5;;;;;:169;;719:10:1;;14806:4:5;;14832:7;;14861:4;;14714:169;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;14714:169:5;;;;;;;;-1:-1:-1;;14714:169:5;;;;;;;;;;;;:::i;:::-;;;14694:745;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15062:6;:13;15079:1;15062:18;15058:367;;15104:106;;-1:-1:-1;;;15104:106:5;;;;;;;:::i;15058:367::-;15377:6;15371:13;15362:6;15358:2;15354:15;15347:38;14694:745;-1:-1:-1;;;;;;14945:51:5;-1:-1:-1;;;14945:51:5;;-1:-1:-1;14938:58:5;;14659:832;-1:-1:-1;15476:4:5;14494:1003;;;;;;:::o;16213:396::-;16397:1;16385:9;:13;16381:222;;;-1:-1:-1;;;;;16418:18:5;;;16414:85;;-1:-1:-1;;;;;16456:15:5;;;;;;:9;:15;;;;;:28;;16475:9;;16456:15;:28;;16475:9;;16456:28;:::i;:::-;;;;-1:-1:-1;;16414:85:5;-1:-1:-1;;;;;16516:16:5;;;16512:81;;-1:-1:-1;;;;;16552:13:5;;;;;;:9;:13;;;;;:26;;16569:9;;16552:13;:26;;16569:9;;16552:26;:::i;:::-;;;;-1:-1:-1;;16213:396:5;;;;:::o;4627:992:6:-;4911:22;4961:1;4936:22;4953:4;4936:16;:22::i;:::-;:26;;;;:::i;:::-;4972:18;4993:26;;;:17;:26;;;;;;4911:51;;-1:-1:-1;5123:28:6;;;5119:323;;-1:-1:-1;;;;;5189:18:6;;5167:19;5189:18;;;:12;:18;;;;;;;;:34;;;;;;;;;5238:30;;;;;;:44;;;5354:30;;:17;:30;;;;;:43;;;5119:323;-1:-1:-1;5535:26:6;;;;:17;:26;;;;;;;;5528:33;;;-1:-1:-1;;;;;5578:18:6;;;;;:12;:18;;;;;:34;;;;;;;5571:41;4627:992::o;5907:1061::-;6181:10;:17;6156:22;;6181:21;;6201:1;;6181:21;:::i;:::-;6212:18;6233:24;;;:15;:24;;;;;;6601:10;:26;;6156:46;;-1:-1:-1;6233:24:6;;6156:46;;6601:26;;;;;;:::i;:::-;;;;;;;;;6579:48;;6663:11;6638:10;6649;6638:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;6742:28;;;:15;:28;;;;;;;:41;;;6911:24;;;;;6904:31;6945:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;5978:990;;;5907:1061;:::o;3437:217::-;3521:14;3538:20;3555:2;3538:16;:20::i;:::-;-1:-1:-1;;;;;3568:16:6;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;3612:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;3437:217:6:o;9366:920:5:-;-1:-1:-1;;;;;9445:16:5;;9437:61;;;;-1:-1:-1;;;9437:61:5;;18486:2:23;9437:61:5;;;18468:21:23;;;18505:18;;;18498:30;18564:34;18544:18;;;18537:62;18616:18;;9437:61:5;18284:356:23;9437:61:5;7550:4;7159:16;;;:7;:16;;;;;;-1:-1:-1;;;;;7159:16:5;7573:31;9508:58;;;;-1:-1:-1;;;9508:58:5;;18847:2:23;9508:58:5;;;18829:21:23;18886:2;18866:18;;;18859:30;18925;18905:18;;;18898:58;18973:18;;9508:58:5;18645:352:23;9508:58:5;9577:48;9606:1;9610:2;9614:7;9623:1;9577:20;:48::i;:::-;7550:4;7159:16;;;:7;:16;;;;;;-1:-1:-1;;;;;7159:16:5;7573:31;9712:58;;;;-1:-1:-1;;;9712:58:5;;18847:2:23;9712:58:5;;;18829:21:23;18886:2;18866:18;;;18859:30;18925;18905:18;;;18898:58;18973:18;;9712:58:5;18645:352:23;9712:58:5;-1:-1:-1;;;;;10112:13:5;;;;;;:9;:13;;;;;;;;:18;;10129:1;10112:18;;;10151:16;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;10151:21:5;;;;;10188:33;10159:7;;10112:13;;10188:33;;10112:13;;10188:33;498:170:9;;:::o;14:131:23:-;-1:-1:-1;;;;;;88:32:23;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;:::-;384:5;150:245;-1:-1:-1;;;150:245:23:o;592:173::-;660:20;;-1:-1:-1;;;;;709:31:23;;699:42;;689:70;;755:1;752;745:12;689:70;592:173;;;:::o;770:179::-;837:20;;-1:-1:-1;;;;;886:38:23;;876:49;;866:77;;939:1;936;929:12;954:258;1021:6;1029;1082:2;1070:9;1061:7;1057:23;1053:32;1050:52;;;1098:1;1095;1088:12;1050:52;1121:29;1140:9;1121:29;:::i;:::-;1111:39;;1169:37;1202:2;1191:9;1187:18;1169:37;:::i;:::-;1159:47;;954:258;;;;;:::o;1217:250::-;1302:1;1312:113;1326:6;1323:1;1320:13;1312:113;;;1402:11;;;1396:18;1383:11;;;1376:39;1348:2;1341:10;1312:113;;;-1:-1:-1;;1459:1:23;1441:16;;1434:27;1217:250::o;1472:271::-;1514:3;1552:5;1546:12;1579:6;1574:3;1567:19;1595:76;1664:6;1657:4;1652:3;1648:14;1641:4;1634:5;1630:16;1595:76;:::i;:::-;1725:2;1704:15;-1:-1:-1;;1700:29:23;1691:39;;;;1732:4;1687:50;;1472:271;-1:-1:-1;;1472:271:23:o;1748:220::-;1897:2;1886:9;1879:21;1860:4;1917:45;1958:2;1947:9;1943:18;1935:6;1917:45;:::i;1973:180::-;2032:6;2085:2;2073:9;2064:7;2060:23;2056:32;2053:52;;;2101:1;2098;2091:12;2053:52;-1:-1:-1;2124:23:23;;1973:180;-1:-1:-1;1973:180:23:o;2366:254::-;2434:6;2442;2495:2;2483:9;2474:7;2470:23;2466:32;2463:52;;;2511:1;2508;2501:12;2463:52;2534:29;2553:9;2534:29;:::i;:::-;2524:39;2610:2;2595:18;;;;2582:32;;-1:-1:-1;;;2366:254:23:o;2807:328::-;2884:6;2892;2900;2953:2;2941:9;2932:7;2928:23;2924:32;2921:52;;;2969:1;2966;2959:12;2921:52;2992:29;3011:9;2992:29;:::i;:::-;2982:39;;3040:38;3074:2;3063:9;3059:18;3040:38;:::i;:::-;3030:48;;3125:2;3114:9;3110:18;3097:32;3087:42;;2807:328;;;;;:::o;3140:248::-;3208:6;3216;3269:2;3257:9;3248:7;3244:23;3240:32;3237:52;;;3285:1;3282;3275:12;3237:52;-1:-1:-1;;3308:23:23;;;3378:2;3363:18;;;3350:32;;-1:-1:-1;3140:248:23:o;3912:326::-;3988:6;3996;4004;4057:2;4045:9;4036:7;4032:23;4028:32;4025:52;;;4073:1;4070;4063:12;4025:52;4109:9;4096:23;4086:33;;4138:38;4172:2;4161:9;4157:18;4138:38;:::i;:::-;4128:48;;4195:37;4228:2;4217:9;4213:18;4195:37;:::i;:::-;4185:47;;3912:326;;;;;:::o;4243:186::-;4302:6;4355:2;4343:9;4334:7;4330:23;4326:32;4323:52;;;4371:1;4368;4361:12;4323:52;4394:29;4413:9;4394:29;:::i;4434:118::-;4520:5;4513:13;4506:21;4499:5;4496:32;4486:60;;4542:1;4539;4532:12;4557:315;4622:6;4630;4683:2;4671:9;4662:7;4658:23;4654:32;4651:52;;;4699:1;4696;4689:12;4651:52;4722:29;4741:9;4722:29;:::i;:::-;4712:39;;4801:2;4790:9;4786:18;4773:32;4814:28;4836:5;4814:28;:::i;:::-;4861:5;4851:15;;;4557:315;;;;;:::o;4877:127::-;4938:10;4933:3;4929:20;4926:1;4919:31;4969:4;4966:1;4959:15;4993:4;4990:1;4983:15;5009:275;5080:2;5074:9;5145:2;5126:13;;-1:-1:-1;;5122:27:23;5110:40;;5180:18;5165:34;;5201:22;;;5162:62;5159:88;;;5227:18;;:::i;:::-;5263:2;5256:22;5009:275;;-1:-1:-1;5009:275:23:o;5289:186::-;5337:4;5370:18;5362:6;5359:30;5356:56;;;5392:18;;:::i;:::-;-1:-1:-1;5458:2:23;5437:15;-1:-1:-1;;5433:29:23;5464:4;5429:40;;5289:186::o;5480:888::-;5575:6;5583;5591;5599;5652:3;5640:9;5631:7;5627:23;5623:33;5620:53;;;5669:1;5666;5659:12;5620:53;5692:29;5711:9;5692:29;:::i;:::-;5682:39;;5740:38;5774:2;5763:9;5759:18;5740:38;:::i;:::-;5730:48;;5825:2;5814:9;5810:18;5797:32;5787:42;;5880:2;5869:9;5865:18;5852:32;5907:18;5899:6;5896:30;5893:50;;;5939:1;5936;5929:12;5893:50;5962:22;;6015:4;6007:13;;6003:27;-1:-1:-1;5993:55:23;;6044:1;6041;6034:12;5993:55;6080:2;6067:16;6105:48;6121:31;6149:2;6121:31;:::i;:::-;6105:48;:::i;:::-;6176:2;6169:5;6162:17;6216:7;6211:2;6206;6202;6198:11;6194:20;6191:33;6188:53;;;6237:1;6234;6227:12;6188:53;6292:2;6287;6283;6279:11;6274:2;6267:5;6263:14;6250:45;6336:1;6331:2;6326;6319:5;6315:14;6311:23;6304:34;6357:5;6347:15;;;;;5480:888;;;;;;;:::o;6373:260::-;6441:6;6449;6502:2;6490:9;6481:7;6477:23;6473:32;6470:52;;;6518:1;6515;6508:12;6470:52;6541:29;6560:9;6541:29;:::i;:::-;6531:39;;6589:38;6623:2;6612:9;6608:18;6589:38;:::i;6638:380::-;6717:1;6713:12;;;;6760;;;6781:61;;6835:4;6827:6;6823:17;6813:27;;6781:61;6888:2;6880:6;6877:14;6857:18;6854:38;6851:161;;6934:10;6929:3;6925:20;6922:1;6915:31;6969:4;6966:1;6959:15;6997:4;6994:1;6987:15;6851:161;;6638:380;;;:::o;7023:127::-;7084:10;7079:3;7075:20;7072:1;7065:31;7115:4;7112:1;7105:15;7139:4;7136:1;7129:15;7155:168;7228:9;;;7259;;7276:15;;;7270:22;;7256:37;7246:71;;7297:18;;:::i;7328:217::-;7368:1;7394;7384:132;;7438:10;7433:3;7429:20;7426:1;7419:31;7473:4;7470:1;7463:15;7501:4;7498:1;7491:15;7384:132;-1:-1:-1;7530:9:23;;7328:217::o;8375:127::-;8436:10;8431:3;8427:20;8424:1;8417:31;8467:4;8464:1;8457:15;8491:4;8488:1;8481:15;10237:648;10317:6;10370:2;10358:9;10349:7;10345:23;10341:32;10338:52;;;10386:1;10383;10376:12;10338:52;10419:9;10413:16;10452:18;10444:6;10441:30;10438:50;;;10484:1;10481;10474:12;10438:50;10507:22;;10560:4;10552:13;;10548:27;-1:-1:-1;10538:55:23;;10589:1;10586;10579:12;10538:55;10618:2;10612:9;10643:48;10659:31;10687:2;10659:31;:::i;10643:48::-;10714:2;10707:5;10700:17;10754:7;10749:2;10744;10740;10736:11;10732:20;10729:33;10726:53;;;10775:1;10772;10765:12;10726:53;10788:67;10852:2;10847;10840:5;10836:14;10831:2;10827;10823:11;10788:67;:::i;:::-;10874:5;10237:648;-1:-1:-1;;;;;10237:648:23:o;11658:406::-;11860:2;11842:21;;;11899:2;11879:18;;;11872:30;11938:34;11933:2;11918:18;;11911:62;-1:-1:-1;;;12004:2:23;11989:18;;11982:40;12054:3;12039:19;;11658:406::o;12732:245::-;12799:6;12852:2;12840:9;12831:7;12827:23;12823:32;12820:52;;;12868:1;12865;12858:12;12820:52;12900:9;12894:16;12919:28;12941:5;12919:28;:::i;13814:409::-;14016:2;13998:21;;;14055:2;14035:18;;;14028:30;14094:34;14089:2;14074:18;;14067:62;-1:-1:-1;;;14160:2:23;14145:18;;14138:43;14213:3;14198:19;;13814:409::o;14584:125::-;14649:9;;;14670:10;;;14667:36;;;14683:18;;:::i;14714:128::-;14781:9;;;14802:11;;;14799:37;;;14816:18;;:::i;15398:401::-;15600:2;15582:21;;;15639:2;15619:18;;;15612:30;15678:34;15673:2;15658:18;;15651:62;-1:-1:-1;;;15744:2:23;15729:18;;15722:35;15789:3;15774:19;;15398:401::o;16563:414::-;16765:2;16747:21;;;16804:2;16784:18;;;16777:30;16843:34;16838:2;16823:18;;16816:62;-1:-1:-1;;;16909:2:23;16894:18;;16887:48;16967:3;16952:19;;16563:414::o;17404:489::-;-1:-1:-1;;;;;17673:15:23;;;17655:34;;17725:15;;17720:2;17705:18;;17698:43;17772:2;17757:18;;17750:34;;;17820:3;17815:2;17800:18;;17793:31;;;17598:4;;17841:46;;17867:19;;17859:6;17841:46;:::i;:::-;17833:54;17404:489;-1:-1:-1;;;;;;17404:489:23:o;17898:249::-;17967:6;18020:2;18008:9;17999:7;17995:23;17991:32;17988:52;;;18036:1;18033;18026:12;17988:52;18068:9;18062:16;18087:30;18111:5;18087:30;:::i;18152:127::-;18213:10;18208:3;18204:20;18201:1;18194:31;18244:4;18241:1;18234:15;18268:4;18265:1;18258:15

ipfs://0f774dc869ebc89937afd01070f9fa6b028e475f067162b82200aedac12c017c