Token

Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Fellowship
// contract by steviep.eth

/*

███████ ███████  ██████  ██    ██ ███████ ██      ███████
██      ██      ██    ██ ██    ██ ██      ██      ██
███████ █████   ██    ██ ██    ██ █████   ██      ███████
     ██ ██      ██ ▄▄ ██ ██    ██ ██      ██           ██
███████ ███████  ██████   ██████  ███████ ███████ ███████
                    ▀▀

*/

import "./Dependencies.sol";
import "./SequelsMetadata.sol";
import "./OperatorFiltererDependencies.sol";

pragma solidity ^0.8.17;

address constant CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS = 0x000000000000AAeB6D7670E522A718067333cd4E;
address constant CANONICAL_CORI_SUBSCRIPTION = 0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6;

abstract contract OperatorFilterer is UpdatableOperatorFilterer {
  constructor() UpdatableOperatorFilterer(
    CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS,
    CANONICAL_CORI_SUBSCRIPTION,
    true
  ) {}
}


contract SequelsBase is ERC721, Ownable, OperatorFilterer {
  uint256 public constant maxSupply = 3652;
  uint256 private _totalSupply = 0;
  SequelsMetadata private _metadataContract;
  address public minter;

  address private royaltyBenificiary;
  uint16 private royaltyBasisPoints = 500;

  constructor() ERC721('Sequels', 'JMS') {
    royaltyBenificiary = msg.sender;
    _metadataContract = new SequelsMetadata(this);
  }

  function mint(address to, uint256 tokenId) external {
    require(minter == msg.sender, 'Caller is not the minting address');
    require(_totalSupply <= maxSupply, 'Cannot exceed max supply');
    _mint(to, tokenId);
    _totalSupply++;
  }

  function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
    return _metadataContract.tokenURI(tokenId);
  }

  function totalSupply() external view returns (uint256) {
    return _totalSupply;
  }

  function exists(uint256 tokenId) external view returns (bool) {
    return _exists(tokenId);
  }

  function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721) returns (bool) {
    // ERC2981
    return interfaceId == bytes4(0x2a55205a) || super.supportsInterface(interfaceId);
  }

  function metadataContract() external view returns (address) {
    return address(_metadataContract);
  }

  function setMetadataContract(address _addr) external onlyOwner {
    _metadataContract = SequelsMetadata(_addr);
  }

  function setMinter(address _addr) external onlyOwner {
    minter = _addr;
  }

  function setRoyaltyInfo(
    address _royaltyBenificiary,
    uint16 _royaltyBasisPoints
  ) external onlyOwner {
    royaltyBenificiary = _royaltyBenificiary;
    royaltyBasisPoints = _royaltyBasisPoints;
  }

  function royaltyInfo(uint256, uint256 _salePrice) external view returns (address, uint256) {
    return (royaltyBenificiary, _salePrice * royaltyBasisPoints / 10000);
  }


  event ProjectEvent(
    address indexed poster,
    string indexed eventType,
    string content
  );
  event TokenEvent(
    address indexed poster,
    uint256 indexed tokenId,
    string indexed eventType,
    string content
  );

  function emitProjectEvent(string calldata eventType, string calldata content) external onlyOwner {
    emit ProjectEvent(_msgSender(), eventType, content);
  }

  function emitTokenEvent(uint256 tokenId, string calldata eventType, string calldata content) external {
    require(
      owner() == _msgSender() || ERC721.ownerOf(tokenId) == _msgSender(),
      'Only project or token owner can emit token event'
    );
    emit TokenEvent(_msgSender(), tokenId, eventType, content);
  }


  /// Operator Filterer

  function owner() public view virtual override(UpdatableOperatorFilterer, Ownable) returns (address) {
    return super.owner();
  }

  /**
   * @dev See {IERC721-setApprovalForAll}.
   *      In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
   */
  function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {
    super.setApprovalForAll(operator, approved);
  }

  /**
   * @dev See {IERC721-approve}.
   *      In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
   */
  function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) {
    super.approve(operator, tokenId);
  }

  /**
   * @dev See {IERC721-transferFrom}.
   *      In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
   */
  function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
    super.transferFrom(from, to, tokenId);
  }

  /**
   * @dev See {IERC721-safeTransferFrom}.
   *      In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
   */
  function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
    super.safeTransferFrom(from, to, tokenId);
  }

  /**
   * @dev See {IERC721-safeTransferFrom}.
   *      In this example the added modifier ensures that the operator is allowed by the OperatorFilterRegistry.
   */
  function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
    public
    override
    onlyAllowedOperator(from)
  {
    super.safeTransferFrom(from, to, tokenId, data);
  }
}

// SPDX-License-Identifier: MIT

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



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

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

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

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

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

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

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

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

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

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

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

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



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


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



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

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

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

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

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

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

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

    // *
    //  * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
    //  * with `errorMessage` as a fallback revert reason when `target` reverts.
    //  *
    //  * _Available since v3.1._

    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

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

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

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

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

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

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

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

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

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

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


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

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

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

    // Don't need these

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

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



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



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

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

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

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

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

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

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

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




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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        require(operator != _msgSender(), "ERC721: approve to caller");

        _operatorApprovals[_msgSender()][operator] = approved;
        emit ApprovalForAll(_msgSender(), operator, approved);
    }

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

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

        _transfer(from, to, tokenId);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _beforeTokenTransfer(from, to, tokenId);

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

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

        emit Transfer(from, to, tokenId);
    }

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.13;


interface IOperatorFilterRegistry {
    /**
     * @notice Returns true if operator is not filtered for a given token, either by address or codeHash. Also returns
     *         true if supplied registrant address is not registered.
     */
    function isOperatorAllowed(address registrant, address operator) external view returns (bool);

    /**
     * @notice Registers an address with the registry. May be called by address itself or by EIP-173 owner.
     */
    function register(address registrant) external;

    /**
     * @notice Registers an address with the registry and "subscribes" to another address's filtered operators and codeHashes.
     */
    function registerAndSubscribe(address registrant, address subscription) external;

    /**
     * @notice Registers an address with the registry and copies the filtered operators and codeHashes from another
     *         address without subscribing.
     */
    function registerAndCopyEntries(address registrant, address registrantToCopy) external;

    /**
     * @notice Unregisters an address with the registry and removes its subscription. May be called by address itself or by EIP-173 owner.
     *         Note that this does not remove any filtered addresses or codeHashes.
     *         Also note that any subscriptions to this registrant will still be active and follow the existing filtered addresses and codehashes.
     */
    function unregister(address addr) external;

    /**
     * @notice Update an operator address for a registered address - when filtered is true, the operator is filtered.
     */
    function updateOperator(address registrant, address operator, bool filtered) external;

    /**
     * @notice Update multiple operators for a registered address - when filtered is true, the operators will be filtered. Reverts on duplicates.
     */
    function updateOperators(address registrant, address[] calldata operators, bool filtered) external;

    /**
     * @notice Update a codeHash for a registered address - when filtered is true, the codeHash is filtered.
     */
    function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;

    /**
     * @notice Update multiple codeHashes for a registered address - when filtered is true, the codeHashes will be filtered. Reverts on duplicates.
     */
    function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;

    /**
     * @notice Subscribe an address to another registrant's filtered operators and codeHashes. Will remove previous
     *         subscription if present.
     *         Note that accounts with subscriptions may go on to subscribe to other accounts - in this case,
     *         subscriptions will not be forwarded. Instead the former subscription's existing entries will still be
     *         used.
     */
    function subscribe(address registrant, address registrantToSubscribe) external;

    /**
     * @notice Unsubscribe an address from its current subscribed registrant, and optionally copy its filtered operators and codeHashes.
     */
    function unsubscribe(address registrant, bool copyExistingEntries) external;

    /**
     * @notice Get the subscription address of a given registrant, if any.
     */
    function subscriptionOf(address addr) external returns (address registrant);

    /**
     * @notice Get the set of addresses subscribed to a given registrant.
     *         Note that order is not guaranteed as updates are made.
     */
    function subscribers(address registrant) external returns (address[] memory);

    /**
     * @notice Get the subscriber at a given index in the set of addresses subscribed to a given registrant.
     *         Note that order is not guaranteed as updates are made.
     */
    function subscriberAt(address registrant, uint256 index) external returns (address);

    /**
     * @notice Copy filtered operators and codeHashes from a different registrantToCopy to addr.
     */
    function copyEntriesOf(address registrant, address registrantToCopy) external;

    /**
     * @notice Returns true if operator is filtered by a given address or its subscription.
     */
    function isOperatorFiltered(address registrant, address operator) external returns (bool);

    /**
     * @notice Returns true if the hash of an address's code is filtered by a given address or its subscription.
     */
    function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);

    /**
     * @notice Returns true if a codeHash is filtered by a given address or its subscription.
     */
    function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);

    /**
     * @notice Returns a list of filtered operators for a given address or its subscription.
     */
    function filteredOperators(address addr) external returns (address[] memory);

    /**
     * @notice Returns the set of filtered codeHashes for a given address or its subscription.
     *         Note that order is not guaranteed as updates are made.
     */
    function filteredCodeHashes(address addr) external returns (bytes32[] memory);

    /**
     * @notice Returns the filtered operator at the given index of the set of filtered operators for a given address or
     *         its subscription.
     *         Note that order is not guaranteed as updates are made.
     */
    function filteredOperatorAt(address registrant, uint256 index) external returns (address);

    /**
     * @notice Returns the filtered codeHash at the given index of the list of filtered codeHashes for a given address or
     *         its subscription.
     *         Note that order is not guaranteed as updates are made.
     */
    function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);

    /**
     * @notice Returns true if an address has registered
     */
    function isRegistered(address addr) external returns (bool);

    /**
     * @dev Convenience method to compute the code hash of an arbitrary contract
     */
    function codeHashOf(address addr) external returns (bytes32);
}


/**
 * @title  UpdatableOperatorFilterer
 * @notice Abstract contract whose constructor automatically registers and optionally subscribes to or copies another
 *         registrant's entries in the OperatorFilterRegistry. This contract allows the Owner to update the
 *         OperatorFilterRegistry address via updateOperatorFilterRegistryAddress, including to the zero address,
 *         which will bypass registry checks.
 *         Note that OpenSea will still disable creator earnings enforcement if filtered operators begin fulfilling orders
 *         on-chain, eg, if the registry is revoked or bypassed.
 * @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 UpdatableOperatorFilterer {
    /// @dev Emitted when an operator is not allowed.
    error OperatorNotAllowed(address operator);
    /// @dev Emitted when someone other than the owner is trying to call an only owner function.
    error OnlyOwner();

    event OperatorFilterRegistryAddressUpdated(address newRegistry);

    IOperatorFilterRegistry public operatorFilterRegistry;

    /// @dev The constructor that is called when the contract is being deployed.
    constructor(address _registry, address subscriptionOrRegistrantToCopy, bool subscribe) {
        IOperatorFilterRegistry registry = IOperatorFilterRegistry(_registry);
        operatorFilterRegistry = registry;
        // 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(registry).code.length > 0) {
            if (subscribe) {
                registry.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy);
            } else {
                if (subscriptionOrRegistrantToCopy != address(0)) {
                    registry.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy);
                } else {
                    registry.register(address(this));
                }
            }
        }
    }

    /**
     * @dev A helper function to check if the operator is allowed.
     */
    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);
        }
        _;
    }

    /**
     * @dev A helper function to check if the operator approval is allowed.
     */
    modifier onlyAllowedOperatorApproval(address operator) virtual {
        _checkFilterOperator(operator);
        _;
    }

    /**
     * @notice Update the address that the contract will make OperatorFilter checks against. When set to the zero
     *         address, checks will be bypassed. OnlyOwner.
     */
    function updateOperatorFilterRegistryAddress(address newRegistry) public virtual {
        if (msg.sender != owner()) {
            revert OnlyOwner();
        }
        operatorFilterRegistry = IOperatorFilterRegistry(newRegistry);
        emit OperatorFilterRegistryAddressUpdated(newRegistry);
    }

    /**
     * @dev Assume the contract has an owner, but leave specific Ownable implementation up to inheriting contract.
     */
    function owner() public view virtual returns (address);

    /**
     * @dev A helper function to check if the operator is allowed.
     */
    function _checkFilterOperator(address operator) internal view virtual {
        IOperatorFilterRegistry registry = operatorFilterRegistry;
        // Check registry code length to facilitate testing in environments without a deployed registry.
        if (address(registry) != address(0) && address(registry).code.length > 0) {
            // under normal circumstances, this function will revert rather than return false, but inheriting contracts
            // may specify their own OperatorFilterRegistry implementations, which may behave differently
            if (!registry.isOperatorAllowed(address(this), operator)) {
                revert OperatorNotAllowed(operator);
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// Copyright (c) 2022 Fellowship
// contract by steviep.eth

/*

███████ ███████  ██████  ██    ██ ███████ ██      ███████
██      ██      ██    ██ ██    ██ ██      ██      ██
███████ █████   ██    ██ ██    ██ █████   ██      ███████
     ██ ██      ██ ▄▄ ██ ██    ██ ██      ██           ██
███████ ███████  ██████   ██████  ███████ ███████ ███████
                    ▀▀

███    ███ ███████ ████████  █████  ██████   █████  ████████  █████
████  ████ ██         ██    ██   ██ ██   ██ ██   ██    ██    ██   ██
██ ████ ██ █████      ██    ███████ ██   ██ ███████    ██    ███████
██  ██  ██ ██         ██    ██   ██ ██   ██ ██   ██    ██    ██   ██
██      ██ ███████    ██    ██   ██ ██████  ██   ██    ██    ██   ██

*/

import "./SequelsBase.sol";
import "./Dependencies.sol";

pragma solidity ^0.8.17;

contract SequelsMetadata {
  using Strings for uint256;

  SequelsBase public sequelsBase;
  string public ipfsCid;

  constructor(SequelsBase _sequelsBase) {
    sequelsBase = _sequelsBase;
  }

  function owner() public view returns (address) {
    return sequelsBase.owner();
  }

  function setIpfsCid(string calldata cid) external {
    require(msg.sender == owner(), "Ownable: caller is not the owner");
    ipfsCid = cid;
  }

  function tokenURI(uint256 tokenId) external view returns (string memory) {
    return string(abi.encodePacked('ipfs://', ipfsCid, '/', tokenId.toString()));
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"OnlyOwner","type":"error"},{"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":false,"internalType":"address","name":"newRegistry","type":"address"}],"name":"OperatorFilterRegistryAddressUpdated","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":"poster","type":"address"},{"indexed":true,"internalType":"string","name":"eventType","type":"string"},{"indexed":false,"internalType":"string","name":"content","type":"string"}],"name":"ProjectEvent","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"poster","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":true,"internalType":"string","name":"eventType","type":"string"},{"indexed":false,"internalType":"string","name":"content","type":"string"}],"name":"TokenEvent","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"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":[{"internalType":"string","name":"eventType","type":"string"},{"internalType":"string","name":"content","type":"string"}],"name":"emitProjectEvent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"string","name":"eventType","type":"string"},{"internalType":"string","name":"content","type":"string"}],"name":"emitTokenEvent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"metadataContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"minter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"operatorFilterRegistry","outputs":[{"internalType":"contract IOperatorFilterRegistry","name":"","type":"address"}],"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":"","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":"_addr","type":"address"}],"name":"setMetadataContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"setMinter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_royaltyBenificiary","type":"address"},{"internalType":"uint16","name":"_royaltyBasisPoints","type":"uint16"}],"name":"setRoyaltyInfo","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":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newRegistry","type":"address"}],"name":"updateOperatorFilterRegistryAddress","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

1273:4481:2:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2283:205;;;;;;:::i;:::-;;:::i;:::-;;;565:14:4;;558:22;540:41;;528:2;513:18;2283:205:2;;;;;;;;22609:98:0;;;:::i;:::-;;;;;;;:::i;1460:21:2:-;;;;;-1:-1:-1;;;;;1460:21:2;;;;;;-1:-1:-1;;;;;1512:32:4;;;1494:51;;1482:2;1467:18;1460:21:2;1348:203:4;24120:217:0;;;;;;:::i;:::-;;:::i;4574:149:2:-;;;;;;:::i;:::-;;:::i;:::-;;2094:85;2162:12;;2094:85;;;2324:25:4;;;2312:2;2297:18;2094:85:2;2178:177:4;4890:155:2;;;;;;:::i;:::-;;:::i;3015:170::-;;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;3138:32:4;;;3120:51;;3202:2;3187:18;;3180:34;;;;3093:18;3015:170:2;2946:274:4;2492:104:2;2573:17;;-1:-1:-1;;;;;2573:17:2;2492:104;;1704:241;;;;;;:::i;:::-;;:::i;5216:163::-;;;;;;:::i;:::-;;:::i;2183:96::-;;;;;;:::i;:::-;;:::i;3589:322::-;;;;;;:::i;:::-;;:::i;22312:235:0:-;;;;;;:::i;:::-;;:::i;22050:205::-;;;;;;:::i;:::-;;:::i;19890:92::-;;;:::i;2802:209:2:-;;;;;;:::i;:::-;;:::i;3941:131::-;;;:::i;22771:102:0:-;;;:::i;4244:168:2:-;;;;;;:::i;:::-;;:::i;7473:53:1:-;;;;;-1:-1:-1;;;;;7473:53:1;;;5550:202:2;;;;;;:::i;:::-;;:::i;9451:302:1:-;;;;;;:::i;:::-;;:::i;1949:141:2:-;;;;;;:::i;:::-;;:::i;3426:159::-;;;;;;:::i;:::-;;:::i;1335:40::-;;1371:4;1335:40;;2600:116;;;;;;:::i;:::-;;:::i;24760:162:0:-;;;;;;:::i;:::-;;:::i;20131:189::-;;;;;;:::i;:::-;;:::i;2720:78:2:-;;;;;;:::i;:::-;;:::i;2283:205::-;2376:4;-1:-1:-1;;;;;;2410:33:2;;-1:-1:-1;;;2410:33:2;;:73;;;2447:36;2471:11;2447:23;:36::i;:::-;2403:80;2283:205;-1:-1:-1;;2283:205:2:o;22609:98:0:-;22663:13;22695:5;22688:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22609:98;:::o;24120:217::-;24196:7;27505:16;;;:7;:16;;;;;;-1:-1:-1;;;;;27505:16:0;24215:73;;;;-1:-1:-1;;;24215:73:0;;8671:2:4;24215:73:0;;;8653:21:4;8710:2;8690:18;;;8683:30;8749:34;8729:18;;;8722:62;-1:-1:-1;;;8800:18:4;;;8793:42;8852:19;;24215:73:0;;;;;;;;;-1:-1:-1;24306:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;24306:24:0;;24120:217::o;4574:149:2:-;4670:8;9207:30:1;9228:8;9207:20;:30::i;:::-;4686:32:2::1;4700:8;4710:7;4686:13;:32::i;:::-;4574:149:::0;;;:::o;4890:155::-;4991:4;-1:-1:-1;;;;;8942:18:1;;8950:10;8942:18;8938:81;;8976:32;8997:10;8976:20;:32::i;:::-;5003:37:2::1;5022:4;5028:2;5032:7;5003:18;:37::i;:::-;4890:155:::0;;;;:::o;3015:170::-;3120:18;;3088:7;;;;-1:-1:-1;;;;;3120:18:2;;;3174:5;;3140:31;;-1:-1:-1;;;3153:18:2;;;;3140:10;:31;:::i;:::-;:39;;;;:::i;:::-;3112:68;;;;3015:170;;;;;;:::o;1704:241::-;1770:6;;-1:-1:-1;;;;;1770:6:2;1780:10;1770:20;1762:66;;;;-1:-1:-1;;;1762:66:2;;9611:2:4;1762:66:2;;;9593:21:4;9650:2;9630:18;;;9623:30;9689:34;9669:18;;;9662:62;-1:-1:-1;;;9740:18:4;;;9733:31;9781:19;;1762:66:2;9409:397:4;1762:66:2;1371:4;1842:12;;:25;;1834:62;;;;-1:-1:-1;;;1834:62:2;;10013:2:4;1834:62:2;;;9995:21:4;10052:2;10032:18;;;10025:30;10091:26;10071:18;;;10064:54;10135:18;;1834:62:2;9811:348:4;1834:62:2;1902:18;1908:2;1912:7;1902:5;:18::i;:::-;1926:12;:14;;;:12;:14;;;:::i;:::-;;;;;;1704:241;;:::o;5216:163::-;5321:4;-1:-1:-1;;;;;8942:18:1;;8950:10;8942:18;8938:81;;8976:32;8997:10;8976:20;:32::i;:::-;5333:41:2::1;5356:4;5362:2;5366:7;5333:22;:41::i;2183:96::-:0;2239:4;27505:16:0;;;:7;:16;;;;;;-1:-1:-1;;;;;27505:16:0;:30;;2258:16:2;27417:125:0;3589:322:2;15458:10:0;3712:7:2;:5;:7::i;:::-;-1:-1:-1;;;;;3712:23:2;;:66;;;-1:-1:-1;15458:10:0;3739:23:2;3754:7;3739:14;:23::i;:::-;-1:-1:-1;;;;;3739:39:2;;3712:66;3697:145;;;;-1:-1:-1;;;3697:145:2;;10506:2:4;3697:145:2;;;10488:21:4;10545:2;10525:18;;;10518:30;10584:34;10564:18;;;10557:62;-1:-1:-1;;;10635:18:4;;;10628:46;10691:19;;3697:145:2;10304:412:4;3697:145:2;3887:9;;3853:53;;;;;;;:::i;:::-;;;;;;;;3878:7;3864:12;15458:10:0;;15379:96;3864:12:2;-1:-1:-1;;;;;3853:53:2;;3898:7;;3853:53;;;;;;;:::i;:::-;;;;;;;;3589:322;;;;;:::o;22312:235:0:-;22384:7;22419:16;;;:7;:16;;;;;;-1:-1:-1;;;;;22419:16:0;;22445:73;;;;-1:-1:-1;;;22445:73:0;;11596:2:4;22445:73:0;;;11578:21:4;11635:2;11615:18;;;11608:30;11674:34;11654:18;;;11647:62;-1:-1:-1;;;11725:18:4;;;11718:39;11774:19;;22445:73:0;11394:405:4;22050:205:0;22122:7;-1:-1:-1;;;;;22149:19:0;;22141:74;;;;-1:-1:-1;;;22141:74:0;;12006:2:4;22141:74:0;;;11988:21:4;12045:2;12025:18;;;12018:30;12084:34;12064:18;;;12057:62;-1:-1:-1;;;12135:18:4;;;12128:40;12185:19;;22141:74:0;11804:406:4;22141:74:0;-1:-1:-1;;;;;;22232:16:0;;;;;:9;:16;;;;;;;22050:205::o;19890:92::-;15458:10;19470:7;:5;:7::i;:::-;-1:-1:-1;;;;;19470:23:0;;19462:68;;;;-1:-1:-1;;;19462:68:0;;;;;;;:::i;:::-;19954:21:::1;19972:1;19954:9;:21::i;:::-;19890:92::o:0;2802:209:2:-;15458:10:0;19470:7;:5;:7::i;:::-;-1:-1:-1;;;;;19470:23:0;;19462:68;;;;-1:-1:-1;;;19462:68:0;;;;;;;:::i;:::-;2920:18:2::1;:40:::0;;2966::::1;::::0;;::::1;-1:-1:-1::0;;;2966:40:2::1;-1:-1:-1::0;;;;;;2966:40:2;;;-1:-1:-1;;;;;2920:40:2;;::::1;2966::::0;;;;::::1;::::0;;2802:209::o;3941:131::-;4032:7;4054:13;19330:6:0;;-1:-1:-1;;;;;19330:6:0;;19258:85;4054:13:2;4047:20;;3941:131;:::o;22771:102:0:-;22827:13;22859:7;22852:14;;;;;:::i;4244:168:2:-;4348:8;9207:30:1;9228:8;9207:20;:30::i;:::-;4364:43:2::1;4388:8;4398;4364:23;:43::i;5550:202::-:0;5686:4;-1:-1:-1;;;;;8942:18:1;;8950:10;8942:18;8938:81;;8976:32;8997:10;8976:20;:32::i;:::-;5700:47:2::1;5723:4;5729:2;5733:7;5742:4;5700:22;:47::i;:::-;5550:202:::0;;;;;:::o;9451:302:1:-;9560:7;:5;:7::i;:::-;-1:-1:-1;;;;;9546:21:1;:10;-1:-1:-1;;;;;9546:21:1;;9542:70;;9590:11;;-1:-1:-1;;;9590:11:1;;;;;;;;;;;9542:70;9621:22;:61;;-1:-1:-1;;;;;;9621:61:1;-1:-1:-1;;;;;9621:61:1;;;;;;;;9697:49;;1494:51:4;;;9697:49:1;;1482:2:4;1467:18;9697:49:1;;;;;;;9451:302;:::o;1949:141:2:-;2050:17;;:35;;-1:-1:-1;;;2050:35:2;;;;;2324:25:4;;;2022:13:2;;-1:-1:-1;;;;;2050:17:2;;:26;;2297:18:4;;2050:35:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;2050:35:2;;;;;;;;;;;;:::i;3426:159::-;15458:10:0;19470:7;:5;:7::i;:::-;-1:-1:-1;;;;;19470:23:0;;19462:68;;;;-1:-1:-1;;;19462:68:0;;;;;;;:::i;:::-;3561:9:2::1;;3534:46;;;;;;;:::i;:::-;;;;;;;;3547:12;15458:10:0::0;;15379:96;3547:12:2::1;-1:-1:-1::0;;;;;3534:46:2::1;;3572:7;;3534:46;;;;;;;:::i;:::-;;;;;;;;3426:159:::0;;;;:::o;2600:116::-;15458:10:0;19470:7;:5;:7::i;:::-;-1:-1:-1;;;;;19470:23:0;;19462:68;;;;-1:-1:-1;;;19462:68:0;;;;;;;:::i;:::-;2669:17:2::1;:42:::0;;-1:-1:-1;;;;;;2669:42:2::1;-1:-1:-1::0;;;;;2669:42:2;;;::::1;::::0;;;::::1;::::0;;2600:116::o;24760:162:0:-;-1:-1:-1;;;;;24880:25:0;;;24857:4;24880:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;24760:162::o;20131:189::-;15458:10;19470:7;:5;:7::i;:::-;-1:-1:-1;;;;;19470:23:0;;19462:68;;;;-1:-1:-1;;;19462:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;20219:22:0;::::1;20211:73;;;::::0;-1:-1:-1;;;20211:73:0;;13431:2:4;20211:73:0::1;::::0;::::1;13413:21:4::0;13470:2;13450:18;;;13443:30;13509:34;13489:18;;;13482:62;-1:-1:-1;;;13560:18:4;;;13553:36;13606:19;;20211:73:0::1;13229:402:4::0;20211:73:0::1;20294:19;20304:8;20294:9;:19::i;:::-;20131:189:::0;:::o;2720:78:2:-;15458:10:0;19470:7;:5;:7::i;:::-;-1:-1:-1;;;;;19470:23:0;;19462:68;;;;-1:-1:-1;;;19462:68:0;;;;;;;:::i;:::-;2779:6:2::1;:14:::0;;-1:-1:-1;;;;;;2779:14:2::1;-1:-1:-1::0;;;;;2779:14:2;;;::::1;::::0;;;::::1;::::0;;2720:78::o;21691:300:0:-;21793:4;-1:-1:-1;;;;;;21828:40:0;;-1:-1:-1;;;21828:40:0;;:104;;-1:-1:-1;;;;;;;21884:48:0;;-1:-1:-1;;;21884:48:0;21828:104;:156;;;-1:-1:-1;;;;;;;;;;18322:40:0;;;21948:36;18214:155;10034:708:1;10149:22;;-1:-1:-1;;;;;10149:22:1;10290:31;;;;;:68;;;10357:1;10333:8;-1:-1:-1;;;;;10325:29:1;;:33;10290:68;10286:450;;;10605:51;;-1:-1:-1;;;10605:51:1;;10640:4;10605:51;;;13848:34:4;-1:-1:-1;;;;;13918:15:4;;;13898:18;;;13891:43;10605:26:1;;;;;13783:18:4;;10605:51:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;10600:126;;10683:28;;-1:-1:-1;;;10683:28:1;;-1:-1:-1;;;;;1512:32:4;;10683:28:1;;;1494:51:4;1467:18;;10683:28:1;1348:203:4;10600:126:1;10104:638;10034:708;:::o;23658:401:0:-;23738:13;23754:23;23769:7;23754:14;:23::i;:::-;23738:39;;23801:5;-1:-1:-1;;;;;23795:11:0;:2;-1:-1:-1;;;;;23795:11:0;;23787:57;;;;-1:-1:-1;;;23787:57:0;;14397:2:4;23787:57:0;;;14379:21:4;14436:2;14416:18;;;14409:30;14475:34;14455:18;;;14448:62;-1:-1:-1;;;14526:18:4;;;14519:31;14567:19;;23787:57:0;14195:397:4;23787:57:0;15458:10;-1:-1:-1;;;;;23876:21:0;;;;:62;;-1:-1:-1;23901:37:0;23918:5;15458:10;24760:162;:::i;23901:37::-;23855:165;;;;-1:-1:-1;;;23855:165:0;;14799:2:4;23855:165:0;;;14781:21:4;14838:2;14818:18;;;14811:30;14877:34;14857:18;;;14850:62;14948:26;14928:18;;;14921:54;14992:19;;23855:165:0;14597:420:4;23855:165:0;24031:21;24040:2;24044:7;24031:8;:21::i;24984:330::-;25173:41;15458:10;25206:7;25173:18;:41::i;:::-;25165:103;;;;-1:-1:-1;;;25165:103:0;;;;;;;:::i;:::-;25279:28;25289:4;25295:2;25299:7;25279:9;:28::i;29336:372::-;-1:-1:-1;;;;;29415:16:0;;29407:61;;;;-1:-1:-1;;;29407:61:0;;15642:2:4;29407:61:0;;;15624:21:4;;;15661:18;;;15654:30;15720:34;15700:18;;;15693:62;15772:18;;29407:61:0;15440:356:4;29407:61:0;27482:4;27505:16;;;:7;:16;;;;;;-1:-1:-1;;;;;27505:16:0;:30;29478:58;;;;-1:-1:-1;;;29478:58:0;;16003:2:4;29478:58:0;;;15985:21:4;16042:2;16022:18;;;16015:30;16081;16061:18;;;16054:58;16129:18;;29478:58:0;15801:352:4;29478:58:0;-1:-1:-1;;;;;29603:13:0;;;;;;:9;:13;;;;;:18;;29620:1;;29603:13;:18;;29620:1;;29603:18;:::i;:::-;;;;-1:-1:-1;;29631:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;29631:21:0;-1:-1:-1;;;;;29631:21:0;;;;;;;;29668:33;;29631:16;;;29668:33;;29631:16;;29668:33;29336:372;;:::o;25380:179::-;25513:39;25530:4;25536:2;25540:7;25513:39;;;;;;;;;;;;:16;:39::i;20326:169::-;20400:6;;;-1:-1:-1;;;;;20416:17:0;;;-1:-1:-1;;;;;;20416:17:0;;;;;;;20448:40;;20400:6;;;20416:17;20400:6;;20448:40;;20381:16;;20448:40;20371:124;20326:169;:::o;24404:290::-;15458:10;-1:-1:-1;;;;;24506:24:0;;;24498:62;;;;-1:-1:-1;;;24498:62:0;;16490:2:4;24498:62:0;;;16472:21:4;16529:2;16509:18;;;16502:30;16568:27;16548:18;;;16541:55;16613:18;;24498:62:0;16288:349:4;24498:62:0;15458:10;24571:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;24571:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;24571:53:0;;;;;;;;;;24639:48;;540:41:4;;;24571:42:0;;15458:10;24639:48;;513:18:4;24639:48:0;;;;;;;24404:290;;:::o;25625:320::-;25794:41;15458:10;25827:7;25794:18;:41::i;:::-;25786:103;;;;-1:-1:-1;;;25786:103:0;;;;;;;:::i;:::-;25899:39;25913:4;25919:2;25923:7;25932:5;25899:13;:39::i;31268:171::-;31342:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;31342:29:0;-1:-1:-1;;;;;31342:29:0;;;;;;;;:24;;31395:23;31342:24;31395:14;:23::i;:::-;-1:-1:-1;;;;;31386:46:0;;;;;;;;;;;31268:171;;:::o;27700:344::-;27793:4;27505:16;;;:7;:16;;;;;;-1:-1:-1;;;;;27505:16:0;27809:73;;;;-1:-1:-1;;;27809:73:0;;16844:2:4;27809:73:0;;;16826:21:4;16883:2;16863:18;;;16856:30;16922:34;16902:18;;;16895:62;-1:-1:-1;;;16973:18:4;;;16966:42;17025:19;;27809:73:0;16642:408:4;27809:73:0;27892:13;27908:23;27923:7;27908:14;:23::i;:::-;27892:39;;27960:5;-1:-1:-1;;;;;27949:16:0;:7;-1:-1:-1;;;;;27949:16:0;;:51;;;;27993:7;-1:-1:-1;;;;;27969:31:0;:20;27981:7;27969:11;:20::i;:::-;-1:-1:-1;;;;;27969:31:0;;27949:51;:87;;;;28004:32;28021:5;28028:7;28004:16;:32::i;:::-;27941:96;27700:344;-1:-1:-1;;;;27700:344:0:o;30597:560::-;30751:4;-1:-1:-1;;;;;30724:31:0;:23;30739:7;30724:14;:23::i;:::-;-1:-1:-1;;;;;30724:31:0;;30716:85;;;;-1:-1:-1;;;30716:85:0;;17257:2:4;30716:85:0;;;17239:21:4;17296:2;17276:18;;;17269:30;17335:34;17315:18;;;17308:62;-1:-1:-1;;;17386:18:4;;;17379:39;17435:19;;30716:85:0;17055:405:4;30716:85:0;-1:-1:-1;;;;;30819:16:0;;30811:65;;;;-1:-1:-1;;;30811:65:0;;17667:2:4;30811:65:0;;;17649:21:4;17706:2;17686:18;;;17679:30;17745:34;17725:18;;;17718:62;-1:-1:-1;;;17796:18:4;;;17789:34;17840:19;;30811:65:0;17465:400:4;30811:65:0;30988:29;31005:1;31009:7;30988:8;:29::i;:::-;-1:-1:-1;;;;;31028:15:0;;;;;;:9;:15;;;;;:20;;31047:1;;31028:15;:20;;31047:1;;31028:20;:::i;:::-;;;;-1:-1:-1;;;;;;;31058:13:0;;;;;;:9;:13;;;;;:18;;31075:1;;31058:13;:18;;31075:1;;31058:18;:::i;:::-;;;;-1:-1:-1;;31086:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;31086:21:0;-1:-1:-1;;;;;31086:21:0;;;;;;;;;31123:27;;31086:16;;31123:27;;;;;;;30597:560;;;:::o;26807:307::-;26958:28;26968:4;26974:2;26978:7;26958:9;:28::i;:::-;27004:48;27027:4;27033:2;27037:7;27046:5;27004:22;:48::i;:::-;26996:111;;;;-1:-1:-1;;;26996:111:0;;;;;;;:::i;31992:782::-;32142:4;-1:-1:-1;;;;;32162:13:0;;7778:20;7824:8;32158:610;;32197:72;;-1:-1:-1;;;32197:72:0;;-1:-1:-1;;;;;32197:36:0;;;;;:72;;15458:10;;32248:4;;32254:7;;32263:5;;32197:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;32197:72:0;;;;;;;;-1:-1:-1;;32197:72:0;;;;;;;;;;;;:::i;:::-;;;32193:523;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32440:6;:13;32457:1;32440:18;32436:266;;32482:60;;-1:-1:-1;;;32482:60:0;;;;;;;:::i;32436:266::-;32654:6;32648:13;32639:6;32635:2;32631:15;32624:38;32193:523;-1:-1:-1;;;;;;32319:55:0;-1:-1:-1;;;32319:55:0;;-1:-1:-1;32312:62:0;;32158:610;-1:-1:-1;32753:4:0;31992:782;;;;;;:::o;14:131:4:-;-1:-1:-1;;;;;;88:32:4;;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:4:o;592:250::-;677:1;687:113;701:6;698:1;695:13;687:113;;;777:11;;;771:18;758:11;;;751:39;723:2;716:10;687:113;;;-1:-1:-1;;834:1:4;816:16;;809:27;592:250::o;847:271::-;889:3;927:5;921:12;954:6;949:3;942:19;970:76;1039:6;1032:4;1027:3;1023:14;1016:4;1009:5;1005:16;970:76;:::i;:::-;1100:2;1079:15;-1:-1:-1;;1075:29:4;1066:39;;;;1107:4;1062:50;;847:271;-1:-1:-1;;847:271:4:o;1123:220::-;1272:2;1261:9;1254:21;1235:4;1292:45;1333:2;1322:9;1318:18;1310:6;1292:45;:::i;1556:180::-;1615:6;1668:2;1656:9;1647:7;1643:23;1639:32;1636:52;;;1684:1;1681;1674:12;1636:52;-1:-1:-1;1707:23:4;;1556:180;-1:-1:-1;1556:180:4:o;1741:173::-;1809:20;;-1:-1:-1;;;;;1858:31:4;;1848:42;;1838:70;;1904:1;1901;1894:12;1838:70;1741:173;;;:::o;1919:254::-;1987:6;1995;2048:2;2036:9;2027:7;2023:23;2019:32;2016:52;;;2064:1;2061;2054:12;2016:52;2087:29;2106:9;2087:29;:::i;:::-;2077:39;2163:2;2148:18;;;;2135:32;;-1:-1:-1;;;1919:254:4:o;2360:328::-;2437:6;2445;2453;2506:2;2494:9;2485:7;2481:23;2477:32;2474:52;;;2522:1;2519;2512:12;2474:52;2545:29;2564:9;2545:29;:::i;:::-;2535:39;;2593:38;2627:2;2616:9;2612:18;2593:38;:::i;:::-;2583:48;;2678:2;2667:9;2663:18;2650:32;2640:42;;2360:328;;;;;:::o;2693:248::-;2761:6;2769;2822:2;2810:9;2801:7;2797:23;2793:32;2790:52;;;2838:1;2835;2828:12;2790:52;-1:-1:-1;;2861:23:4;;;2931:2;2916:18;;;2903:32;;-1:-1:-1;2693:248:4:o;3225:348::-;3277:8;3287:6;3341:3;3334:4;3326:6;3322:17;3318:27;3308:55;;3359:1;3356;3349:12;3308:55;-1:-1:-1;3382:20:4;;3425:18;3414:30;;3411:50;;;3457:1;3454;3447:12;3411:50;3494:4;3486:6;3482:17;3470:29;;3546:3;3539:4;3530:6;3522;3518:19;3514:30;3511:39;3508:59;;;3563:1;3560;3553:12;3578:789;3679:6;3687;3695;3703;3711;3764:2;3752:9;3743:7;3739:23;3735:32;3732:52;;;3780:1;3777;3770:12;3732:52;3816:9;3803:23;3793:33;;3877:2;3866:9;3862:18;3849:32;3900:18;3941:2;3933:6;3930:14;3927:34;;;3957:1;3954;3947:12;3927:34;3996:59;4047:7;4038:6;4027:9;4023:22;3996:59;:::i;:::-;4074:8;;-1:-1:-1;3970:85:4;-1:-1:-1;4162:2:4;4147:18;;4134:32;;-1:-1:-1;4178:16:4;;;4175:36;;;4207:1;4204;4197:12;4175:36;;4246:61;4299:7;4288:8;4277:9;4273:24;4246:61;:::i;:::-;3578:789;;;;-1:-1:-1;3578:789:4;;-1:-1:-1;4326:8:4;;4220:87;3578:789;-1:-1:-1;;;3578:789:4:o;4372:186::-;4431:6;4484:2;4472:9;4463:7;4459:23;4455:32;4452:52;;;4500:1;4497;4490:12;4452:52;4523:29;4542:9;4523:29;:::i;4563:346::-;4630:6;4638;4691:2;4679:9;4670:7;4666:23;4662:32;4659:52;;;4707:1;4704;4697:12;4659:52;4730:29;4749:9;4730:29;:::i;:::-;4720:39;;4809:2;4798:9;4794:18;4781:32;4853:6;4846:5;4842:18;4835:5;4832:29;4822:57;;4875:1;4872;4865:12;4822:57;4898:5;4888:15;;;4563:346;;;;;:::o;4914:118::-;5000:5;4993:13;4986:21;4979:5;4976:32;4966:60;;5022:1;5019;5012:12;5037:315;5102:6;5110;5163:2;5151:9;5142:7;5138:23;5134:32;5131:52;;;5179:1;5176;5169:12;5131:52;5202:29;5221:9;5202:29;:::i;:::-;5192:39;;5281:2;5270:9;5266:18;5253:32;5294:28;5316:5;5294:28;:::i;5597:127::-;5658:10;5653:3;5649:20;5646:1;5639:31;5689:4;5686:1;5679:15;5713:4;5710:1;5703:15;5729:275;5800:2;5794:9;5865:2;5846:13;;-1:-1:-1;;5842:27:4;5830:40;;5900:18;5885:34;;5921:22;;;5882:62;5879:88;;;5947:18;;:::i;:::-;5983:2;5976:22;5729:275;;-1:-1:-1;5729:275:4:o;6009:186::-;6057:4;6090:18;6082:6;6079:30;6076:56;;;6112:18;;:::i;:::-;-1:-1:-1;6178:2:4;6157:15;-1:-1:-1;;6153:29:4;6184:4;6149:40;;6009:186::o;6200:888::-;6295:6;6303;6311;6319;6372:3;6360:9;6351:7;6347:23;6343:33;6340:53;;;6389:1;6386;6379:12;6340:53;6412:29;6431:9;6412:29;:::i;:::-;6402:39;;6460:38;6494:2;6483:9;6479:18;6460:38;:::i;:::-;6450:48;;6545:2;6534:9;6530:18;6517:32;6507:42;;6600:2;6589:9;6585:18;6572:32;6627:18;6619:6;6616:30;6613:50;;;6659:1;6656;6649:12;6613:50;6682:22;;6735:4;6727:13;;6723:27;-1:-1:-1;6713:55:4;;6764:1;6761;6754:12;6713:55;6800:2;6787:16;6825:48;6841:31;6869:2;6841:31;:::i;:::-;6825:48;:::i;:::-;6896:2;6889:5;6882:17;6936:7;6931:2;6926;6922;6918:11;6914:20;6911:33;6908:53;;;6957:1;6954;6947:12;6908:53;7012:2;7007;7003;6999:11;6994:2;6987:5;6983:14;6970:45;7056:1;7051:2;7046;7039:5;7035:14;7031:23;7024:34;7077:5;7067:15;;;;;6200:888;;;;;;;:::o;7093:721::-;7185:6;7193;7201;7209;7262:2;7250:9;7241:7;7237:23;7233:32;7230:52;;;7278:1;7275;7268:12;7230:52;7318:9;7305:23;7347:18;7388:2;7380:6;7377:14;7374:34;;;7404:1;7401;7394:12;7374:34;7443:59;7494:7;7485:6;7474:9;7470:22;7443:59;:::i;:::-;7521:8;;-1:-1:-1;7417:85:4;-1:-1:-1;7609:2:4;7594:18;;7581:32;;-1:-1:-1;7625:16:4;;;7622:36;;;7654:1;7651;7644:12;7622:36;;7693:61;7746:7;7735:8;7724:9;7720:24;7693:61;:::i;:::-;7093:721;;;;-1:-1:-1;7773:8:4;-1:-1:-1;;;;7093:721:4:o;7819:260::-;7887:6;7895;7948:2;7936:9;7927:7;7923:23;7919:32;7916:52;;;7964:1;7961;7954:12;7916:52;7987:29;8006:9;7987:29;:::i;:::-;7977:39;;8035:38;8069:2;8058:9;8054:18;8035:38;:::i;:::-;8025:48;;7819:260;;;;;:::o;8084:380::-;8163:1;8159:12;;;;8206;;;8227:61;;8281:4;8273:6;8269:17;8259:27;;8227:61;8334:2;8326:6;8323:14;8303:18;8300:38;8297:161;;8380:10;8375:3;8371:20;8368:1;8361:31;8415:4;8412:1;8405:15;8443:4;8440:1;8433:15;8297:161;;8084:380;;;:::o;8882:127::-;8943:10;8938:3;8934:20;8931:1;8924:31;8974:4;8971:1;8964:15;8998:4;8995:1;8988:15;9014:168;9087:9;;;9118;;9135:15;;;9129:22;;9115:37;9105:71;;9156:18;;:::i;9187:217::-;9227:1;9253;9243:132;;9297:10;9292:3;9288:20;9285:1;9278:31;9332:4;9329:1;9322:15;9360:4;9357:1;9350:15;9243:132;-1:-1:-1;9389:9:4;;9187:217::o;10164:135::-;10203:3;10224:17;;;10221:43;;10244:18;;:::i;:::-;-1:-1:-1;10291:1:4;10280:13;;10164:135::o;10721:273::-;10906:6;10898;10893:3;10880:33;10862:3;10932:16;;10957:13;;;10932:16;10721:273;-1:-1:-1;10721:273:4:o;10999:390::-;11158:2;11147:9;11140:21;11197:6;11192:2;11181:9;11177:18;11170:34;11254:6;11246;11241:2;11230:9;11226:18;11213:48;11310:1;11281:22;;;11305:2;11277:31;;;11270:42;;;;11373:2;11352:15;;;-1:-1:-1;;11348:29:4;11333:45;11329:54;;10999:390;-1:-1:-1;10999:390:4:o;12215:356::-;12417:2;12399:21;;;12436:18;;;12429:30;12495:34;12490:2;12475:18;;12468:62;12562:2;12547:18;;12215:356::o;12576:648::-;12656:6;12709:2;12697:9;12688:7;12684:23;12680:32;12677:52;;;12725:1;12722;12715:12;12677:52;12758:9;12752:16;12791:18;12783:6;12780:30;12777:50;;;12823:1;12820;12813:12;12777:50;12846:22;;12899:4;12891:13;;12887:27;-1:-1:-1;12877:55:4;;12928:1;12925;12918:12;12877:55;12957:2;12951:9;12982:48;12998:31;13026:2;12998:31;:::i;12982:48::-;13053:2;13046:5;13039:17;13093:7;13088:2;13083;13079;13075:11;13071:20;13068:33;13065:53;;;13114:1;13111;13104:12;13065:53;13127:67;13191:2;13186;13179:5;13175:14;13170:2;13166;13162:11;13127:67;:::i;:::-;13213:5;12576:648;-1:-1:-1;;;;;12576:648:4:o;13945:245::-;14012:6;14065:2;14053:9;14044:7;14040:23;14036:32;14033:52;;;14081:1;14078;14071:12;14033:52;14113:9;14107:16;14132:28;14154:5;14132:28;:::i;15022:413::-;15224:2;15206:21;;;15263:2;15243:18;;;15236:30;15302:34;15297:2;15282:18;;15275:62;-1:-1:-1;;;15368:2:4;15353:18;;15346:47;15425:3;15410:19;;15022:413::o;16158:125::-;16223:9;;;16244:10;;;16241:36;;;16257:18;;:::i;17870:128::-;17937:9;;;17958:11;;;17955:37;;;17972:18;;:::i;18003:414::-;18205:2;18187:21;;;18244:2;18224:18;;;18217:30;18283:34;18278:2;18263:18;;18256:62;-1:-1:-1;;;18349:2:4;18334:18;;18327:48;18407:3;18392:19;;18003:414::o;18422:489::-;-1:-1:-1;;;;;18691:15:4;;;18673:34;;18743:15;;18738:2;18723:18;;18716:43;18790:2;18775:18;;18768:34;;;18838:3;18833:2;18818:18;;18811:31;;;18616:4;;18859:46;;18885:19;;18877:6;18859:46;:::i;:::-;18851:54;18422:489;-1:-1:-1;;;;;;18422:489:4:o;18916:249::-;18985:6;19038:2;19026:9;19017:7;19013:23;19009:32;19006:52;;;19054:1;19051;19044:12;19006:52;19086:9;19080:16;19105:30;19129:5;19105:30;:::i

ipfs://18fbbfef2a78ad3851c8da78f4d5d6720882b8b84670ccc0bae028ac5eedd629