Datasets:

Zellic
/

smart-contract-fiesta

	// This contract is part of Zellic’s smart contract dataset, which is a collection of publicly available contract code gathered as of March 2023.

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

	// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/IERC721.sol)

	pragma solidity ^0.8.0;


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

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

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

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

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

	/**
	* @dev Safely transfers `tokenId` token from `from` to `to`.
	*
	* 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: 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 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);
	}

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

	pragma solidity ^0.8.0;



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

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

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



	// ERC721A Contracts v3.3.0
	// Creator: Chiru Labs

	pragma solidity ^0.8.4;



	/**
	* @dev Interface of an ERC721A compliant contract.
	*/
	interface IERC721A is IERC721, IERC721Metadata {
	/**
	* The caller must own the token or be an approved operator.
	*/
	error ApprovalCallerNotOwnerNorApproved();

	/**
	* The token does not exist.
	*/
	error ApprovalQueryForNonexistentToken();

	/**
	* The caller cannot approve to their own address.
	*/
	error ApproveToCaller();

	/**
	* The caller cannot approve to the current owner.
	*/
	error ApprovalToCurrentOwner();

	/**
	* Cannot query the balance for the zero address.
	*/
	error BalanceQueryForZeroAddress();

	/**
	* Cannot mint to the zero address.
	*/
	error MintToZeroAddress();

	/**
	* The quantity of tokens minted must be more than zero.
	*/
	error MintZeroQuantity();

	/**
	* The token does not exist.
	*/
	error OwnerQueryForNonexistentToken();

	/**
	* The caller must own the token or be an approved operator.
	*/
	error TransferCallerNotOwnerNorApproved();

	/**
	* The token must be owned by `from`.
	*/
	error TransferFromIncorrectOwner();

	/**
	* Cannot safely transfer to a contract that does not implement the ERC721Receiver interface.
	*/
	error TransferToNonERC721ReceiverImplementer();

	/**
	* Cannot transfer to the zero address.
	*/
	error TransferToZeroAddress();

	/**
	* The token does not exist.
	*/
	error URIQueryForNonexistentToken();

	// Compiler will pack this into a single 256bit word.
	struct TokenOwnership {
	// The address of the owner.
	address addr;
	// Keeps track of the start time of ownership with minimal overhead for tokenomics.
	uint64 startTimestamp;
	// Whether the token has been burned.
	bool burned;
	}

	// Compiler will pack this into a single 256bit word.
	struct AddressData {
	// Realistically, 2**64-1 is more than enough.
	uint64 balance;
	// Keeps track of mint count with minimal overhead for tokenomics.
	uint64 numberMinted;
	// Keeps track of burn count with minimal overhead for tokenomics.
	uint64 numberBurned;
	// For miscellaneous variable(s) pertaining to the address
	// (e.g. number of whitelist mint slots used).
	// If there are multiple variables, please pack them into a uint64.
	uint64 aux;
	}

	/**
	* @dev Returns the total amount of tokens stored by the contract.
	*
	* Burned tokens are calculated here, use `_totalMinted()` if you want to count just minted tokens.
	*/
	function totalSupply() external view returns (uint256);
	}


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

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

	pragma solidity ^0.8.0;



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

	// ERC721A Contracts v3.3.0
	// Creator: Chiru Labs

	pragma solidity ^0.8.4;


	/**
	* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
	* the Metadata extension. Built to optimize for lower gas during batch mints.
	*
	* Assumes serials are sequentially minted starting at _startTokenId() (defaults to 0, e.g. 0, 1, 2, 3..).
	*
	* Assumes that an owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
	*
	* Assumes that the maximum token id cannot exceed 2**256 - 1 (max value of uint256).
	*/
	contract ERC721A is Context, ERC165, IERC721A {
	using Address for address;
	using Strings for uint256;

	// The tokenId of the next token to be minted.
	uint256 internal _currentIndex;

	// The number of tokens burned.
	uint256 internal _burnCounter;

	// Token name
	string private _name;

	// Token symbol
	string private _symbol;

	// Mapping from token ID to ownership details
	// An empty struct value does not necessarily mean the token is unowned. See _ownershipOf implementation for details.
	mapping(uint256 => TokenOwnership) internal _ownerships;

	// Mapping owner address to address data
	mapping(address => AddressData) private _addressData;

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

	constructor(string memory name_, string memory symbol_) {
	_name = name_;
	_symbol = symbol_;
	_currentIndex = _startTokenId();
	}

	/**
	* To change the starting tokenId, please override this function.
	*/
	function _startTokenId() internal view virtual returns (uint256) {
	return 0;
	}

	/**
	* @dev Burned tokens are calculated here, use _totalMinted() if you want to count just minted tokens.
	*/
	function totalSupply() public view override returns (uint256) {
	// Counter underflow is impossible as _burnCounter cannot be incremented
	// more than _currentIndex - _startTokenId() times
	unchecked {
	return _currentIndex - _burnCounter - _startTokenId();
	}
	}

	/**
	* Returns the total amount of tokens minted in the contract.
	*/
	function _totalMinted() internal view returns (uint256) {
	// Counter underflow is impossible as _currentIndex does not decrement,
	// and it is initialized to _startTokenId()
	unchecked {
	return _currentIndex - _startTokenId();
	}
	}

	/**
	* @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 override returns (uint256) {
	if (owner == address(0)) revert BalanceQueryForZeroAddress();
	return uint256(_addressData[owner].balance);
	}

	/**
	* Returns the number of tokens minted by `owner`.
	*/
	function _numberMinted(address owner) internal view returns (uint256) {
	return uint256(_addressData[owner].numberMinted);
	}

	/**
	* Returns the number of tokens burned by or on behalf of `owner`.
	*/
	function _numberBurned(address owner) internal view returns (uint256) {
	return uint256(_addressData[owner].numberBurned);
	}

	/**
	* Returns the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
	*/
	function _getAux(address owner) internal view returns (uint64) {
	return _addressData[owner].aux;
	}

	/**
	* Sets the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
	* If there are multiple variables, please pack them into a uint64.
	*/
	function _setAux(address owner, uint64 aux) internal {
	_addressData[owner].aux = aux;
	}

	/**
	* Gas spent here starts off proportional to the maximum mint batch size.
	* It gradually moves to O(1) as tokens get transferred around in the collection over time.
	*/
	function _ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
	uint256 curr = tokenId;

	unchecked {
	if (_startTokenId() <= curr) if (curr < _currentIndex) {
	TokenOwnership memory ownership = _ownerships[curr];
	if (!ownership.burned) {
	if (ownership.addr != address(0)) {
	return ownership;
	}
	// Invariant:
	// There will always be an ownership that has an address and is not burned
	// before an ownership that does not have an address and is not burned.
	// Hence, curr will not underflow.
	while (true) {
	curr--;
	ownership = _ownerships[curr];
	if (ownership.addr != address(0)) {
	return ownership;
	}
	}
	}
	}
	}
	revert OwnerQueryForNonexistentToken();
	}

	/**
	* @dev See {IERC721-ownerOf}.
	*/
	function ownerOf(uint256 tokenId) public view override returns (address) {
	return _ownershipOf(tokenId).addr;
	}

	/**
	* @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) {
	if (!_exists(tokenId)) revert URIQueryForNonexistentToken();

	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 override {
	address owner = ERC721A.ownerOf(tokenId);
	if (to == owner) revert ApprovalToCurrentOwner();

	if (_msgSender() != owner) if(!isApprovedForAll(owner, _msgSender())) {
	revert ApprovalCallerNotOwnerNorApproved();
	}

	_approve(to, tokenId, owner);
	}

	/**
	* @dev See {IERC721-getApproved}.
	*/
	function getApproved(uint256 tokenId) public view override returns (address) {
	if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();

	return _tokenApprovals[tokenId];
	}

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

	_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 {
	_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 {
	_transfer(from, to, tokenId);
	if (to.isContract()) if(!_checkContractOnERC721Received(from, to, tokenId, _data)) {
	revert TransferToNonERC721ReceiverImplementer();
	}
	}

	/**
	* @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`),
	*/
	function _exists(uint256 tokenId) internal view returns (bool) {
	return _startTokenId() <= tokenId && tokenId < _currentIndex && !_ownerships[tokenId].burned;
	}

	/**
	* @dev Equivalent to `_safeMint(to, quantity, '')`.
	*/
	function _safeMint(address to, uint256 quantity) internal {
	_safeMint(to, quantity, '');
	}

	/**
	* @dev Safely mints `quantity` tokens and transfers them to `to`.
	*
	* Requirements:
	*
	* - If `to` refers to a smart contract, it must implement
	* {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
	* - `quantity` must be greater than 0.
	*
	* Emits a {Transfer} event.
	*/
	function _safeMint(
	address to,
	uint256 quantity,
	bytes memory _data
	) internal {
	uint256 startTokenId = _currentIndex;
	if (to == address(0)) revert MintToZeroAddress();
	if (quantity == 0) revert MintZeroQuantity();

	_beforeTokenTransfers(address(0), to, startTokenId, quantity);

	// Overflows are incredibly unrealistic.
	// balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
	// updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
	unchecked {
	_addressData[to].balance += uint64(quantity);
	_addressData[to].numberMinted += uint64(quantity);

	_ownerships[startTokenId].addr = to;
	_ownerships[startTokenId].startTimestamp = uint64(block.timestamp);

	uint256 updatedIndex = startTokenId;
	uint256 end = updatedIndex + quantity;

	if (to.isContract()) {
	do {
	emit Transfer(address(0), to, updatedIndex);
	if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) {
	revert TransferToNonERC721ReceiverImplementer();
	}
	} while (updatedIndex < end);
	// Reentrancy protection
	if (_currentIndex != startTokenId) revert();
	} else {
	do {
	emit Transfer(address(0), to, updatedIndex++);
	} while (updatedIndex < end);
	}
	_currentIndex = updatedIndex;
	}
	_afterTokenTransfers(address(0), to, startTokenId, quantity);
	}

	/**
	* @dev Mints `quantity` tokens and transfers them to `to`.
	*
	* Requirements:
	*
	* - `to` cannot be the zero address.
	* - `quantity` must be greater than 0.
	*
	* Emits a {Transfer} event.
	*/
	function _mint(address to, uint256 quantity) internal {
	uint256 startTokenId = _currentIndex;
	if (to == address(0)) revert MintToZeroAddress();
	if (quantity == 0) revert MintZeroQuantity();

	_beforeTokenTransfers(address(0), to, startTokenId, quantity);

	// Overflows are incredibly unrealistic.
	// balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
	// updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
	unchecked {
	_addressData[to].balance += uint64(quantity);
	_addressData[to].numberMinted += uint64(quantity);

	_ownerships[startTokenId].addr = to;
	_ownerships[startTokenId].startTimestamp = uint64(block.timestamp);

	uint256 updatedIndex = startTokenId;
	uint256 end = updatedIndex + quantity;

	do {
	emit Transfer(address(0), to, updatedIndex++);
	} while (updatedIndex < end);

	_currentIndex = updatedIndex;
	}
	_afterTokenTransfers(address(0), to, startTokenId, quantity);
	}

	/**
	* @dev Transfers `tokenId` from `from` to `to`.
	*
	* 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
	) private {
	TokenOwnership memory prevOwnership = _ownershipOf(tokenId);

	if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();

	bool isApprovedOrOwner = (_msgSender() == from \|\|
	isApprovedForAll(from, _msgSender()) \|\|
	getApproved(tokenId) == _msgSender());

	if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
	if (to == address(0)) revert TransferToZeroAddress();

	_beforeTokenTransfers(from, to, tokenId, 1);

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

	// Underflow of the sender's balance is impossible because we check for
	// ownership above and the recipient's balance can't realistically overflow.
	// Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
	unchecked {
	_addressData[from].balance -= 1;
	_addressData[to].balance += 1;

	TokenOwnership storage currSlot = _ownerships[tokenId];
	currSlot.addr = to;
	currSlot.startTimestamp = uint64(block.timestamp);

	// If the ownership slot of tokenId+1 is not explicitly set, that means the transfer initiator owns it.
	// Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
	uint256 nextTokenId = tokenId + 1;
	TokenOwnership storage nextSlot = _ownerships[nextTokenId];
	if (nextSlot.addr == address(0)) {
	// This will suffice for checking _exists(nextTokenId),
	// as a burned slot cannot contain the zero address.
	if (nextTokenId != _currentIndex) {
	nextSlot.addr = from;
	nextSlot.startTimestamp = prevOwnership.startTimestamp;
	}
	}
	}

	emit Transfer(from, to, tokenId);
	_afterTokenTransfers(from, to, tokenId, 1);
	}

	/**
	* @dev Equivalent to `_burn(tokenId, false)`.
	*/
	function _burn(uint256 tokenId) internal virtual {
	_burn(tokenId, false);
	}

	/**
	* @dev Destroys `tokenId`.
	* The approval is cleared when the token is burned.
	*
	* Requirements:
	*
	* - `tokenId` must exist.
	*
	* Emits a {Transfer} event.
	*/
	function _burn(uint256 tokenId, bool approvalCheck) internal virtual {
	TokenOwnership memory prevOwnership = _ownershipOf(tokenId);

	address from = prevOwnership.addr;

	if (approvalCheck) {
	bool isApprovedOrOwner = (_msgSender() == from \|\|
	isApprovedForAll(from, _msgSender()) \|\|
	getApproved(tokenId) == _msgSender());

	if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
	}

	_beforeTokenTransfers(from, address(0), tokenId, 1);

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

	// Underflow of the sender's balance is impossible because we check for
	// ownership above and the recipient's balance can't realistically overflow.
	// Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
	unchecked {
	AddressData storage addressData = _addressData[from];
	addressData.balance -= 1;
	addressData.numberBurned += 1;

	// Keep track of who burned the token, and the timestamp of burning.
	TokenOwnership storage currSlot = _ownerships[tokenId];
	currSlot.addr = from;
	currSlot.startTimestamp = uint64(block.timestamp);
	currSlot.burned = true;

	// If the ownership slot of tokenId+1 is not explicitly set, that means the burn initiator owns it.
	// Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
	uint256 nextTokenId = tokenId + 1;
	TokenOwnership storage nextSlot = _ownerships[nextTokenId];
	if (nextSlot.addr == address(0)) {
	// This will suffice for checking _exists(nextTokenId),
	// as a burned slot cannot contain the zero address.
	if (nextTokenId != _currentIndex) {
	nextSlot.addr = from;
	nextSlot.startTimestamp = prevOwnership.startTimestamp;
	}
	}
	}

	emit Transfer(from, address(0), tokenId);
	_afterTokenTransfers(from, address(0), tokenId, 1);

	// Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.
	unchecked {
	_burnCounter++;
	}
	}

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

	/**
	* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target 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 _checkContractOnERC721Received(
	address from,
	address to,
	uint256 tokenId,
	bytes memory _data
	) private returns (bool) {
	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 TransferToNonERC721ReceiverImplementer();
	} else {
	assembly {
	revert(add(32, reason), mload(reason))
	}
	}
	}
	}

	/**
	* @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
	* And also called before burning one token.
	*
	* startTokenId - the first token id to be transferred
	* quantity - the amount to be transferred
	*
	* 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, `tokenId` will be burned by `from`.
	* - `from` and `to` are never both zero.
	*/
	function _beforeTokenTransfers(
	address from,
	address to,
	uint256 startTokenId,
	uint256 quantity
	) internal virtual {}

	/**
	* @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
	* minting.
	* And also called after one token has been burned.
	*
	* startTokenId - the first token id to be transferred
	* quantity - the amount to be transferred
	*
	* Calling conditions:
	*
	* - When `from` and `to` are both non-zero, `from`'s `tokenId` has been
	* transferred to `to`.
	* - When `from` is zero, `tokenId` has been minted for `to`.
	* - When `to` is zero, `tokenId` has been burned by `from`.
	* - `from` and `to` are never both zero.
	*/
	function _afterTokenTransfers(
	address from,
	address to,
	uint256 startTokenId,
	uint256 quantity
	) internal virtual {}
	}
	// 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);
	}




	// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)

	pragma solidity ^0.8.0;

	/**
	* @dev String operations.
	*/
	library Strings {
	bytes16 private constant _HEX_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) {
	// Inspired by OraclizeAPI's implementation - MIT licence
	// https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

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

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

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

	/**
	* @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);
	}
	}
	// OpenZeppelin Contracts (last updated v4.7.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);
	}
	}
	}


	// OpenZeppelin Contracts (last updated v4.7.0) (utils/cryptography/MerkleProof.sol)

	pragma solidity ^0.8.0;

	/**
	* @dev These functions deal with verification of Merkle Tree proofs.
	*
	* The proofs can be generated using the JavaScript library
	* https://github.com/miguelmota/merkletreejs[merkletreejs].
	* Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
	*
	* See `test/utils/cryptography/MerkleProof.test.js` for some examples.
	*
	* WARNING: You should avoid using leaf values that are 64 bytes long prior to
	* hashing, or use a hash function other than keccak256 for hashing leaves.
	* This is because the concatenation of a sorted pair of internal nodes in
	* the merkle tree could be reinterpreted as a leaf value.
	*/
	library MerkleProof {
	/**
	* @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
	* defined by `root`. For this, a `proof` must be provided, containing
	* sibling hashes on the branch from the leaf to the root of the tree. Each
	* pair of leaves and each pair of pre-images are assumed to be sorted.
	*/
	function verify(
	bytes32[] memory proof,
	bytes32 root,
	bytes32 leaf
	) internal pure returns (bool) {
	return processProof(proof, leaf) == root;
	}

	/**
	* @dev Calldata version of {verify}
	*
	* _Available since v4.7._
	*/
	function verifyCalldata(
	bytes32[] calldata proof,
	bytes32 root,
	bytes32 leaf
	) internal pure returns (bool) {
	return processProofCalldata(proof, leaf) == root;
	}

	/**
	* @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
	* from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
	* hash matches the root of the tree. When processing the proof, the pairs
	* of leafs & pre-images are assumed to be sorted.
	*
	* _Available since v4.4._
	*/
	function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
	bytes32 computedHash = leaf;
	for (uint256 i = 0; i < proof.length; i++) {
	computedHash = _hashPair(computedHash, proof[i]);
	}
	return computedHash;
	}

	/**
	* @dev Calldata version of {processProof}
	*
	* _Available since v4.7._
	*/
	function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
	bytes32 computedHash = leaf;
	for (uint256 i = 0; i < proof.length; i++) {
	computedHash = _hashPair(computedHash, proof[i]);
	}
	return computedHash;
	}

	/**
	* @dev Returns true if the `leaves` can be proved to be a part of a Merkle tree defined by
	* `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
	*
	* _Available since v4.7._
	*/
	function multiProofVerify(
	bytes32[] memory proof,
	bool[] memory proofFlags,
	bytes32 root,
	bytes32[] memory leaves
	) internal pure returns (bool) {
	return processMultiProof(proof, proofFlags, leaves) == root;
	}

	/**
	* @dev Calldata version of {multiProofVerify}
	*
	* _Available since v4.7._
	*/
	function multiProofVerifyCalldata(
	bytes32[] calldata proof,
	bool[] calldata proofFlags,
	bytes32 root,
	bytes32[] memory leaves
	) internal pure returns (bool) {
	return processMultiProofCalldata(proof, proofFlags, leaves) == root;
	}

	/**
	* @dev Returns the root of a tree reconstructed from `leaves` and the sibling nodes in `proof`,
	* consuming from one or the other at each step according to the instructions given by
	* `proofFlags`.
	*
	* _Available since v4.7._
	*/
	function processMultiProof(
	bytes32[] memory proof,
	bool[] memory proofFlags,
	bytes32[] memory leaves
	) internal pure returns (bytes32 merkleRoot) {
	// This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
	// consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
	// `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
	// the merkle tree.
	uint256 leavesLen = leaves.length;
	uint256 totalHashes = proofFlags.length;

	// Check proof validity.
	require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

	// The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
	// `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
	bytes32[] memory hashes = new bytes32[](totalHashes);
	uint256 leafPos = 0;
	uint256 hashPos = 0;
	uint256 proofPos = 0;
	// At each step, we compute the next hash using two values:
	// - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
	// get the next hash.
	// - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
	// `proof` array.
	for (uint256 i = 0; i < totalHashes; i++) {
	bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
	bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
	hashes[i] = _hashPair(a, b);
	}

	if (totalHashes > 0) {
	return hashes[totalHashes - 1];
	} else if (leavesLen > 0) {
	return leaves[0];
	} else {
	return proof[0];
	}
	}

	/**
	* @dev Calldata version of {processMultiProof}
	*
	* _Available since v4.7._
	*/
	function processMultiProofCalldata(
	bytes32[] calldata proof,
	bool[] calldata proofFlags,
	bytes32[] memory leaves
	) internal pure returns (bytes32 merkleRoot) {
	// This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
	// consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
	// `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
	// the merkle tree.
	uint256 leavesLen = leaves.length;
	uint256 totalHashes = proofFlags.length;

	// Check proof validity.
	require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

	// The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
	// `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
	bytes32[] memory hashes = new bytes32[](totalHashes);
	uint256 leafPos = 0;
	uint256 hashPos = 0;
	uint256 proofPos = 0;
	// At each step, we compute the next hash using two values:
	// - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
	// get the next hash.
	// - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
	// `proof` array.
	for (uint256 i = 0; i < totalHashes; i++) {
	bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
	bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
	hashes[i] = _hashPair(a, b);
	}

	if (totalHashes > 0) {
	return hashes[totalHashes - 1];
	} else if (leavesLen > 0) {
	return leaves[0];
	} else {
	return proof[0];
	}
	}

	function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
	return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
	}

	function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
	/// @solidity memory-safe-assembly
	assembly {
	mstore(0x00, a)
	mstore(0x20, b)
	value := keccak256(0x00, 0x40)
	}
	}
	}


	// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

	pragma solidity ^0.8.0;



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

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

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

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



	// Contract ERC721A From: Chiru Labs


	pragma solidity >=0.8.6;


	contract DinoReveal is ERC721A, Ownable {

	uint public price = 0.009 ether;
	uint public maxSupply = 5200;
	uint public maxSupplyPre = 1200;
	uint public maxTx = 3;
	uint public maxTxPre = 1;

	bytes32 public merkleRoot;

	bool private mintOpen = false;
	bool private presaleOpen = false;

	mapping(address => uint256) public _preSaleCounter;

	string internal baseTokenURI = '';

	constructor() ERC721A("DINOREVEAL", "DINOREVEAL") {}

	function toggleMint() external onlyOwner {
	mintOpen = !mintOpen;
	}

	function togglePresale() external onlyOwner {
	presaleOpen = !presaleOpen;
	}

	function setPrice(uint newPrice) external onlyOwner {
	price = newPrice;
	}

	function setBaseTokenURI(string calldata _uri) external onlyOwner {
	baseTokenURI = _uri;
	}

	function setMerkleRoot(bytes32 root) external onlyOwner {
	merkleRoot = root;
	}

	function setMaxSupply(uint newSupply) external onlyOwner {
	maxSupply = newSupply;
	}


	function setMaxTx(uint newMax) external onlyOwner {
	maxTx = newMax;
	}


	function _baseURI() internal override view returns (string memory) {
	return baseTokenURI;
	}

	function buyTo(address to, uint qty) external onlyOwner {
	_mintTo(to, qty);
	}

	function buyPre(uint qty, bytes32[] memory proof) external payable {
	require(presaleOpen, "Mint is not Open Yet.");
	require(
	_preSaleCounter[msg.sender] + qty <= maxTxPre,
	"Exceeded max available to purchase, PreSale Gets 1 Free Only."
	);
	_preSaleCounter[msg.sender] =
	_preSaleCounter[msg.sender] +
	qty;
	require(verify(proof), "Your Address is not on the Whitelist.");
	_buyPre(qty);
	}

	function buy(uint qty) external payable {
	require(mintOpen, "Mint is not Open Yet.");
	require(
	_preSaleCounter[msg.sender] + qty <= maxTx,
	"Exceeded max available to purchase"
	);
	require(msg.value >= price * qty, "PAYMENT: invalid value");
	_preSaleCounter[msg.sender] =
	_preSaleCounter[msg.sender] +
	qty;
	_buy(qty);
	}

	function _buy(uint qty) internal {
	require(qty <= maxTx && qty > 0, "TRANSACTION: qty of mints not alowed");
	require(totalSupply() + qty <= maxSupply, "reached max supply");
	_mintTo(_msgSender(), qty);
	}

	function _buyPre(uint qty) internal {
	require(qty <= maxTxPre && qty > 0, "TRANSACTION: qty of mints not alowed");
	require(totalSupply() + qty <= maxSupplyPre, "reached max supply");
	_mintTo(_msgSender(), qty);
	}

	function _mintTo(address to, uint qty) internal {
	require(qty + totalSupply() <= maxSupply, "SUPPLY: Value exceeds totalSupply");
	_mint(to, qty);
	}

	function withdraw() external onlyOwner {
	payable(_msgSender()).transfer(address(this).balance);
	}

	function verify(bytes32[] memory proof) internal view returns (bool) {
	bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
	return MerkleProof.verify(proof, merkleRoot, leaf);
	}

	function airdrop(address[] calldata _users) external onlyOwner {
	for (uint256 i = 0; i < _users.length; i++) {
	_safeMint(_users[i], 1);
	}
	}

	}

	// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

	pragma solidity ^0.8.0;

	/**
	* @dev Interface of the ERC20 standard as defined in the EIP.
	*/
	interface IERC20 {
	/**
	* @dev Emitted when `value` tokens are moved from one account (`from`) to
	* another (`to`).
	*
	* Note that `value` may be zero.
	*/
	event Transfer(address indexed from, address indexed to, uint256 value);

	/**
	* @dev Emitted when the allowance of a `spender` for an `owner` is set by
	* a call to {approve}. `value` is the new allowance.
	*/
	event Approval(address indexed owner, address indexed spender, uint256 value);

	/**
	* @dev Returns the amount of tokens in existence.
	*/
	function totalSupply() external view returns (uint256);

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

	/**
	* @dev Moves `amount` tokens from the caller's account to `to`.
	*
	* Returns a boolean value indicating whether the operation succeeded.
	*
	* Emits a {Transfer} event.
	*/
	function transfer(address to, uint256 amount) external returns (bool);

	/**
	* @dev Returns the remaining number of tokens that `spender` will be
	* allowed to spend on behalf of `owner` through {transferFrom}. This is
	* zero by default.
	*
	* This value changes when {approve} or {transferFrom} are called.
	*/
	function allowance(address owner, address spender) external view returns (uint256);

	/**
	* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
	*
	* Returns a boolean value indicating whether the operation succeeded.
	*
	* IMPORTANT: Beware that changing an allowance with this method brings the risk
	* that someone may use both the old and the new allowance by unfortunate
	* transaction ordering. One possible solution to mitigate this race
	* condition is to first reduce the spender's allowance to 0 and set the
	* desired value afterwards:
	* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
	*
	* Emits an {Approval} event.
	*/
	function approve(address spender, uint256 amount) external returns (bool);

	/**
	* @dev Moves `amount` tokens from `from` to `to` using the
	* allowance mechanism. `amount` is then deducted from the caller's
	* allowance.
	*
	* Returns a boolean value indicating whether the operation succeeded.
	*
	* Emits a {Transfer} event.
	*/
	function transferFrom(
	address from,
	address to,
	uint256 amount
	) external returns (bool);
	}

	// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

	pragma solidity ^0.8.0;


	/**
	* @dev Interface for the optional metadata functions from the ERC20 standard.
	*
	* _Available since v4.1._
	*/
	interface IERC20Metadata is IERC20 {
	/**
	* @dev Returns the name of the token.
	*/
	function name() external view returns (string memory);

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

	/**
	* @dev Returns the decimals places of the token.
	*/
	function decimals() external view returns (uint8);
	}

	pragma solidity ^0.8.0;


	/**
	* @dev Implementation of the {IERC20} interface.
	*
	* This implementation is agnostic to the way tokens are created. This means
	* that a supply mechanism has to be added in a derived contract using {_mint}.
	* For a generic mechanism see {ERC20PresetMinterPauser}.
	*
	* TIP: For a detailed writeup see our guide
	* https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
	* to implement supply mechanisms].
	*
	* We have followed general OpenZeppelin Contracts guidelines: functions revert
	* instead returning `false` on failure. This behavior is nonetheless
	* conventional and does not conflict with the expectations of ERC20
	* applications.
	*
	* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
	* This allows applications to reconstruct the allowance for all accounts just
	* by listening to said events. Other implementations of the EIP may not emit
	* these events, as it isn't required by the specification.
	*
	* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
	* functions have been added to mitigate the well-known issues around setting
	* allowances. See {IERC20-approve}.
	*/
	contract ERC20 is Context, IERC20, IERC20Metadata {
	mapping(address => uint256) private _balances;

	mapping(address => mapping(address => uint256)) private _allowances;

	uint256 private _totalSupply;

	string private _name;
	string private _symbol;

	/**
	* @dev Sets the values for {name} and {symbol}.
	*
	* The default value of {decimals} is 18. To select a different value for
	* {decimals} you should overload it.
	*
	* All two of these values are immutable: they can only be set once during
	* construction.
	*/
	constructor(string memory name_, string memory symbol_) {
	_name = name_;
	_symbol = symbol_;
	}

	/**
	* @dev Returns the name of the token.
	*/
	function name() public view virtual override returns (string memory) {
	return _name;
	}

	/**
	* @dev Returns the symbol of the token, usually a shorter version of the
	* name.
	*/
	function symbol() public view virtual override returns (string memory) {
	return _symbol;
	}

	/**
	* @dev Returns the number of decimals used to get its user representation.
	* For example, if `decimals` equals `2`, a balance of `505` tokens should
	* be displayed to a user as `5.05` (`505 / 10 ** 2`).
	*
	* Tokens usually opt for a value of 18, imitating the relationship between
	* Ether and Wei. This is the value {ERC20} uses, unless this function is
	* overridden;
	*
	* NOTE: This information is only used for _display_ purposes: it in
	* no way affects any of the arithmetic of the contract, including
	* {IERC20-balanceOf} and {IERC20-transfer}.
	*/
	function decimals() public view virtual override returns (uint8) {
	return 18;
	}

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

	/**
	* @dev See {IERC20-balanceOf}.
	*/
	function balanceOf(address account) public view virtual override returns (uint256) {
	return _balances[account];
	}

	/**
	* @dev See {IERC20-transfer}.
	*
	* Requirements:
	*
	* - `to` cannot be the zero address.
	* - the caller must have a balance of at least `amount`.
	*/
	function transfer(address to, uint256 amount) public virtual override returns (bool) {
	address owner = _msgSender();
	_transfer(owner, to, amount);
	return true;
	}

	/**
	* @dev See {IERC20-allowance}.
	*/
	function allowance(address owner, address spender) public view virtual override returns (uint256) {
	return _allowances[owner][spender];
	}

	/**
	* @dev See {IERC20-approve}.
	*
	* NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
	* `transferFrom`. This is semantically equivalent to an infinite approval.
	*
	* Requirements:
	*
	* - `spender` cannot be the zero address.
	*/
	function approve(address spender, uint256 amount) public virtual override returns (bool) {
	address owner = _msgSender();
	_approve(owner, spender, amount);
	return true;
	}

	/**
	* @dev See {IERC20-transferFrom}.
	*
	* Emits an {Approval} event indicating the updated allowance. This is not
	* required by the EIP. See the note at the beginning of {ERC20}.
	*
	* NOTE: Does not update the allowance if the current allowance
	* is the maximum `uint256`.
	*
	* Requirements:
	*
	* - `from` and `to` cannot be the zero address.
	* - `from` must have a balance of at least `amount`.
	* - the caller must have allowance for ``from``'s tokens of at least
	* `amount`.
	*/
	function transferFrom(
	address from,
	address to,
	uint256 amount
	) public virtual override returns (bool) {
	address spender = _msgSender();
	_spendAllowance(from, spender, amount);
	_transfer(from, to, amount);
	return true;
	}

	/**
	* @dev Atomically increases the allowance granted to `spender` by the caller.
	*
	* This is an alternative to {approve} that can be used as a mitigation for
	* problems described in {IERC20-approve}.
	*
	* Emits an {Approval} event indicating the updated allowance.
	*
	* Requirements:
	*
	* - `spender` cannot be the zero address.
	*/
	function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
	address owner = _msgSender();
	_approve(owner, spender, allowance(owner, spender) + addedValue);
	return true;
	}

	/**
	* @dev Atomically decreases the allowance granted to `spender` by the caller.
	*
	* This is an alternative to {approve} that can be used as a mitigation for
	* problems described in {IERC20-approve}.
	*
	* Emits an {Approval} event indicating the updated allowance.
	*
	* Requirements:
	*
	* - `spender` cannot be the zero address.
	* - `spender` must have allowance for the caller of at least
	* `subtractedValue`.
	*/
	function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
	address owner = _msgSender();
	uint256 currentAllowance = allowance(owner, spender);
	require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
	unchecked {
	_approve(owner, spender, currentAllowance - subtractedValue);
	}

	return true;
	}

	/**
	* @dev Moves `amount` of tokens from `from` to `to`.
	*
	* This internal function is equivalent to {transfer}, and can be used to
	* e.g. implement automatic token fees, slashing mechanisms, etc.
	*
	* Emits a {Transfer} event.
	*
	* Requirements:
	*
	* - `from` cannot be the zero address.
	* - `to` cannot be the zero address.
	* - `from` must have a balance of at least `amount`.
	*/
	function _transfer(
	address from,
	address to,
	uint256 amount
	) internal virtual {
	require(from != address(0), "ERC20: transfer from the zero address");
	require(to != address(0), "ERC20: transfer to the zero address");

	_beforeTokenTransfer(from, to, amount);

	uint256 fromBalance = _balances[from];
	require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
	unchecked {
	_balances[from] = fromBalance - amount;
	// Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
	// decrementing then incrementing.
	_balances[to] += amount;
	}

	emit Transfer(from, to, amount);

	_afterTokenTransfer(from, to, amount);
	}

	/** @dev Creates `amount` tokens and assigns them to `account`, increasing
	* the total supply.
	*
	* Emits a {Transfer} event with `from` set to the zero address.
	*
	* Requirements:
	*
	* - `account` cannot be the zero address.
	*/
	function _mint(address account, uint256 amount) internal virtual {
	require(account != address(0), "ERC20: mint to the zero address");

	_beforeTokenTransfer(address(0), account, amount);

	_totalSupply += amount;
	unchecked {
	// Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
	_balances[account] += amount;
	}
	emit Transfer(address(0), account, amount);

	_afterTokenTransfer(address(0), account, amount);
	}

	/**
	* @dev Destroys `amount` tokens from `account`, reducing the
	* total supply.
	*
	* Emits a {Transfer} event with `to` set to the zero address.
	*
	* Requirements:
	*
	* - `account` cannot be the zero address.
	* - `account` must have at least `amount` tokens.
	*/
	function _burn(address account, uint256 amount) internal virtual {
	require(account != address(0), "ERC20: burn from the zero address");

	_beforeTokenTransfer(account, address(0), amount);

	uint256 accountBalance = _balances[account];
	require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
	unchecked {
	_balances[account] = accountBalance - amount;
	// Overflow not possible: amount <= accountBalance <= totalSupply.
	_totalSupply -= amount;
	}

	emit Transfer(account, address(0), amount);

	_afterTokenTransfer(account, address(0), amount);
	}

	/**
	* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
	*
	* This internal function is equivalent to `approve`, and can be used to
	* e.g. set automatic allowances for certain subsystems, etc.
	*
	* Emits an {Approval} event.
	*
	* Requirements:
	*
	* - `owner` cannot be the zero address.
	* - `spender` cannot be the zero address.
	*/
	function _approve(
	address owner,
	address spender,
	uint256 amount
	) internal virtual {
	require(owner != address(0), "ERC20: approve from the zero address");
	require(spender != address(0), "ERC20: approve to the zero address");

	_allowances[owner][spender] = amount;
	emit Approval(owner, spender, amount);
	}

	/**
	* @dev Updates `owner` s allowance for `spender` based on spent `amount`.
	*
	* Does not update the allowance amount in case of infinite allowance.
	* Revert if not enough allowance is available.
	*
	* Might emit an {Approval} event.
	*/
	function _spendAllowance(
	address owner,
	address spender,
	uint256 amount
	) internal virtual {
	uint256 currentAllowance = allowance(owner, spender);
	if (currentAllowance != type(uint256).max) {
	require(currentAllowance >= amount, "ERC20: insufficient allowance");
	unchecked {
	_approve(owner, spender, currentAllowance - amount);
	}
	}
	}

	/**
	* @dev Hook that is called before any transfer of tokens. This includes
	* minting and burning.
	*
	* Calling conditions:
	*
	* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
	* will be transferred to `to`.
	* - when `from` is zero, `amount` tokens will be minted for `to`.
	* - when `to` is zero, `amount` of ``from``'s tokens 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 amount
	) internal virtual {}

	/**
	* @dev Hook that is called after any transfer of tokens. This includes
	* minting and burning.
	*
	* Calling conditions:
	*
	* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
	* has been transferred to `to`.
	* - when `from` is zero, `amount` tokens have been minted for `to`.
	* - when `to` is zero, `amount` of ``from``'s tokens have been 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 _afterTokenTransfer(
	address from,
	address to,
	uint256 amount
	) internal virtual {}
	}


	// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Burnable.sol)

	pragma solidity ^0.8.0;


	/**
	* @dev Extension of {ERC20} that allows token holders to destroy both their own
	* tokens and those that they have an allowance for, in a way that can be
	* recognized off-chain (via event analysis).
	*/
	abstract contract ERC20Burnable is Context, ERC20 {
	/**
	* @dev Destroys `amount` tokens from the caller.
	*
	* See {ERC20-_burn}.
	*/
	function burn(uint256 amount) public virtual {
	_burn(_msgSender(), amount);
	}

	/**
	* @dev Destroys `amount` tokens from `account`, deducting from the caller's
	* allowance.
	*
	* See {ERC20-_burn} and {ERC20-allowance}.
	*
	* Requirements:
	*
	* - the caller must have allowance for ``accounts``'s tokens of at least
	* `amount`.
	*/
	function burnFrom(address account, uint256 amount) public virtual {
	_spendAllowance(account, _msgSender(), amount);
	_burn(account, amount);
	}
	}


	//Dino-Gem Contract

	pragma solidity >=0.8.6;



	contract DinoToken is ERC20, ERC20Burnable, Ownable {

	mapping(address => bool) controllers;

	constructor() ERC20("DinoGem", "DINOR") { }

	function mint(address to, uint256 amount) external {
	require(controllers[msg.sender], "Only controllers can mint");
	_mint(to, amount);
	}

	function burnFrom(address account, uint256 amount) public override {
	if (controllers[msg.sender]) {
	_burn(account, amount);
	}
	else {
	super.burnFrom(account, amount);
	}
	}

	function addController(address controller) external onlyOwner {
	controllers[controller] = true;
	}

	function removeController(address controller) external onlyOwner {
	controllers[controller] = false;
	}
	}

	pragma solidity >=0.8.6;


	contract DinoStaking is Ownable, IERC721Receiver {

	uint256 public totalStaked;

	// struct to store a stake's token, owner, and earning values
	struct Stake {
	uint24 tokenId;
	uint48 timestamp;
	address owner;
	}

	event NFTStaked(address owner, uint256 tokenId, uint256 value);
	event NFTUnstaked(address owner, uint256 tokenId, uint256 value);
	event Claimed(address owner, uint256 amount);

	// reference to the Block NFT contract
	DinoReveal nft;
	DinoToken token;

	// maps tokenId to stake
	mapping(uint256 => Stake) public vault;

	constructor(DinoReveal _nft, DinoToken _token) {
	nft = _nft;
	token = _token;
	}

	function stake(uint256[] calldata tokenIds) external {
	uint256 tokenId;
	totalStaked += tokenIds.length;
	for (uint i = 0; i < tokenIds.length; i++) {
	tokenId = tokenIds[i];
	require(nft.ownerOf(tokenId) == msg.sender, "not your token");
	require(vault[tokenId].tokenId == 0, 'already staked');

	nft.transferFrom(msg.sender, address(this), tokenId);
	emit NFTStaked(msg.sender, tokenId, block.timestamp);

	vault[tokenId] = Stake({
	owner: msg.sender,
	tokenId: uint24(tokenId),
	timestamp: uint48(block.timestamp)
	});
	}
	}

	function _unstakeMany(address account, uint256[] calldata tokenIds) internal {
	uint256 tokenId;
	totalStaked -= tokenIds.length;
	for (uint i = 0; i < tokenIds.length; i++) {
	tokenId = tokenIds[i];
	Stake memory staked = vault[tokenId];
	require(staked.owner == msg.sender, "not an owner");

	delete vault[tokenId];
	emit NFTUnstaked(account, tokenId, block.timestamp);
	nft.transferFrom(address(this), account, tokenId);
	}
	}

	function claim(uint256[] calldata tokenIds) external {
	_claim(msg.sender, tokenIds, false);
	}

	function claimForAddress(address account, uint256[] calldata tokenIds) external {
	_claim(account, tokenIds, false);
	}

	function unstake(uint256[] calldata tokenIds) external {
	_claim(msg.sender, tokenIds, true);
	}



	function _claim(address account, uint256[] calldata tokenIds, bool _unstake) internal {
	uint256 tokenId;
	uint256 earned = 0;
	uint256 rewardmath = 0;

	for (uint i = 0; i < tokenIds.length; i++) {
	tokenId = tokenIds[i];
	Stake memory staked = vault[tokenId];
	require(staked.owner == account, "not an owner");
	uint256 stakedAt = staked.timestamp;
	rewardmath = 500 ether * (block.timestamp - stakedAt) / 86400 ;
	earned = rewardmath / 100;
	vault[tokenId] = Stake({
	owner: account,
	tokenId: uint24(tokenId),
	timestamp: uint48(block.timestamp)
	});
	}
	if (earned > 0) {
	token.mint(account, earned);
	}
	if (_unstake) {
	_unstakeMany(account, tokenIds);
	}
	emit Claimed(account, earned);
	}

	function earningInfo(address account, uint256[] calldata tokenIds) external view returns (uint256[1] memory info) {
	uint256 tokenId;
	uint256 earned = 0;
	uint256 rewardmath = 0;

	for (uint i = 0; i < tokenIds.length; i++) {
	tokenId = tokenIds[i];
	Stake memory staked = vault[tokenId];
	require(staked.owner == account, "not an owner");
	uint256 stakedAt = staked.timestamp;
	rewardmath = 500 ether * (block.timestamp - stakedAt) / 86400;
	earned = rewardmath / 100;

	}
	if (earned > 0) {
	return [earned];
	}
	}

	// should never be used inside of transaction because of gas fee
	function balanceOf(address account) public view returns (uint256) {
	uint256 balance = 0;
	uint256 supply = nft.totalSupply();
	for(uint i = 1; i <= supply; i++) {
	if (vault[i].owner == account) {
	balance += 1;
	}
	}
	return balance;
	}

	// should never be used inside of transaction because of gas fee
	function tokensOfOwner(address account) public view returns (uint256[] memory ownerTokens) {

	uint256 supply = nft.totalSupply();
	uint256[] memory tmp = new uint256[](supply);

	uint256 index = 0;
	for(uint tokenId = 1; tokenId <= supply; tokenId++) {
	if (vault[tokenId].owner == account) {
	tmp[index] = vault[tokenId].tokenId;
	index +=1;
	}
	}

	uint256[] memory tokens = new uint256[](index);
	for(uint i = 0; i < index; i++) {
	tokens[i] = tmp[i];
	}

	return tokens;
	}

	function onERC721Received(
	address,
	address from,
	uint256,
	bytes calldata
	) external pure override returns (bytes4) {
	require(from == address(0x0), "Cannot send nfts to Vault directly");
	return IERC721Receiver.onERC721Received.selector;
	}

	}