// Contract: CryptoCanyonHeroes
// Target function: function _checkContractOnERC721Received(
	 */
	function _setAux(address owner, uint64 aux) internal virtual {
		uint256 packed = _packedAddressData[owner];
		uint256 auxCasted;
		// Cast `aux` with assembly to avoid redundant masking.
		assembly {
			auxCasted := aux
		}
		packed = (packed & _BITMASK_AUX_COMPLEMENT) | (auxCasted << _BITPOS_AUX);
		_packedAddressData[owner] = packed;
	}
	
	// =============================================================
	//                            IERC165
	// =============================================================
	
	/**
	 * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30000 gas.
     */
	function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
		// The interface IDs are constants representing the first 4 bytes
		// of the XOR of all function selectors in the interface.
		// See: [ERC165](https://eips.ethereum.org/EIPS/eip-165)
		// (e.g. `bytes4(i.functionA.selector ^ i.functionB.selector ^ ...)`)
		return
			interfaceId == 0x01ffc9a7 || // ERC165 interface ID for ERC165.
			interfaceId == 0x80ac58cd || // ERC165 interface ID for ERC721.
			interfaceId == 0x5b5e139f; // ERC165 interface ID for ERC721Metadata.
	}
	
	// =============================================================
	//                        IERC721Metadata
	// =============================================================
	
	/**
	 * @dev Returns the token collection name.
     */
	function name() public view virtual override returns (string memory) {
		return _name;
	}
	
	/**
	 * @dev Returns the token collection symbol.
     */
	function symbol() public view virtual override returns (string memory) {
		return _symbol;
	}
	
	/**
	 * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
	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, _toString(tokenId))) : '';
	}
	
	/**
	 * @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, it can be overridden in child contracts.
     */
	function _baseURI() internal view virtual returns (string memory) {
		return '';
	}
	
	// =============================================================
	//                     OWNERSHIPS OPERATIONS
	// =============================================================
	
	/**
	 * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
	function ownerOf(uint256 tokenId) public view virtual override returns (address) {
		return address(uint160(_packedOwnershipOf(tokenId)));
	}
	
	/**
	 * @dev Gas spent here starts off proportional to the maximum mint batch size.
     * It gradually moves to O(1) as tokens get transferred around over time.
     */
	function _ownershipOf(uint256 tokenId) internal view virtual returns (TokenOwnership memory) {
		return _unpackedOwnership(_packedOwnershipOf(tokenId));
	}
	
	/**
	 * @dev Returns the unpacked `TokenOwnership` struct at `index`.
     */
	function _ownershipAt(uint256 index) internal view virtual returns (TokenOwnership memory) {
		return _unpackedOwnership(_packedOwnerships[index]);
	}
	
	/**
	 * @dev Initializes the ownership slot minted at `index` for efficiency purposes.
     */
	function _initializeOwnershipAt(uint256 index) internal virtual {
		if (_packedOwnerships[index] == 0) {
			_packedOwnerships[index] = _packedOwnershipOf(index);
		}
	}
	
	/**
	 * Returns the packed ownership data of `tokenId`.
	 */
	function _packedOwnershipOf(uint256 tokenId) private view returns (uint256) {
		uint256 curr = tokenId;
		
		unchecked {
			if (_startTokenId() <= curr)
				if (curr < _currentIndex) {
					uint256 packed = _packedOwnerships[curr];
					// If not burned.
					if (packed & _BITMASK_BURNED == 0) {
						// Invariant:
						// There will always be an initialized ownership slot
						// (i.e. `ownership.addr != address(0) && ownership.burned == false`)
						// before an unintialized ownership slot
						// (i.e. `ownership.addr == address(0) && ownership.burned == false`)
						// Hence, `curr` will not underflow.
						//
						// We can directly compare the packed value.
						// If the address is zero, packed will be zero.
						while (packed == 0) {
							packed = _packedOwnerships[--curr];
						}
						return packed;
					}
				}
		}
		revert OwnerQueryForNonexistentToken();
	}
	
	/**
	 * @dev Returns the unpacked `TokenOwnership` struct from `packed`.
     */
	function _unpackedOwnership(uint256 packed) private pure returns (TokenOwnership memory ownership) {
		ownership.addr = address(uint160(packed));
		ownership.startTimestamp = uint64(packed >> _BITPOS_START_TIMESTAMP);
		ownership.burned = packed & _BITMASK_BURNED != 0;
		ownership.extraData = uint24(packed >> _BITPOS_EXTRA_DATA);
	}
	
	/**
	 * @dev Packs ownership data into a single uint256.
     */
	function _packOwnershipData(address owner, uint256 flags) private view returns (uint256 result) {
		assembly {
		// Mask `owner` to the lower 160 bits, in case the upper bits somehow aren't clean.
			owner := and(owner, _BITMASK_ADDRESS)
		// `owner | (block.timestamp << _BITPOS_START_TIMESTAMP) | flags`.
			result := or(owner, or(shl(_BITPOS_START_TIMESTAMP, timestamp()), flags))
		}
	}
	
	/**
	 * @dev Returns the `nextInitialized` flag set if `quantity` equals 1.
     */
	function _nextInitializedFlag(uint256 quantity) private pure returns (uint256 result) {
		// For branchless setting of the `nextInitialized` flag.
		assembly {
		// `(quantity == 1) << _BITPOS_NEXT_INITIALIZED`.
			result := shl(_BITPOS_NEXT_INITIALIZED, eq(quantity, 1))
		}
	}
	
	// =============================================================
	//                      APPROVAL OPERATIONS
	// =============================================================
	
	/**
	 * @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) public virtual override {
		address owner = ownerOf(tokenId);
		
		if (_msgSenderERC721A() != owner)
			if (!isApprovedForAll(owner, _msgSenderERC721A())) {
				revert ApprovalCallerNotOwnerNorApproved();
			}
		
		_tokenApprovals[tokenId].value = to;
		emit Approval(owner, to, tokenId);
	}
	
	/**
	 * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
	function getApproved(uint256 tokenId) public view virtual override returns (address) {
		if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();
		
		return _tokenApprovals[tokenId].value;
	}
	
	/**
	 * @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) public virtual override {
		if (operator == _msgSenderERC721A()) revert ApproveToCaller();
		
		_operatorApprovals[_msgSenderERC721A()][operator] = approved;
		emit ApprovalForAll(_msgSenderERC721A(), operator, approved);
	}
	
	/**
	 * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}.
     */
	function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
		return _operatorApprovals[owner][operator];
	}
	
	/**
	 * @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. See {_mint}.
     */
	function _exists(uint256 tokenId) internal view virtual returns (bool) {
		return
			_startTokenId() <= tokenId &&
			tokenId < _currentIndex && // If within bounds,
			_packedOwnerships[tokenId] & _BITMASK_BURNED == 0; // and not burned.
	}
	
	/**
	 * @dev Returns whether `msgSender` is equal to `approvedAddress` or `owner`.
     */
	function _isSenderApprovedOrOwner(
		address approvedAddress,
		address owner,
		address msgSender
	) private pure returns (bool result) {
		assembly {
		// Mask `owner` to the lower 160 bits, in case the upper bits somehow aren't clean.
			owner := and(owner, _BITMASK_ADDRESS)
		// Mask `msgSender` to the lower 160 bits, in case the upper bits somehow aren't clean.
			msgSender := and(msgSender, _BITMASK_ADDRESS)
		// `msgSender == owner || msgSender == approvedAddress`.
			result := or(eq(msgSender, owner), eq(msgSender, approvedAddress))
		}
	}
	
	/**
	 * @dev Returns the storage slot and value for the approved address of `tokenId`.
     */
	function _getApprovedSlotAndAddress(uint256 tokenId)
	private
	view
	returns (uint256 approvedAddressSlot, address approvedAddress)
	{
		TokenApprovalRef storage tokenApproval = _tokenApprovals[tokenId];
		// The following is equivalent to `approvedAddress = _tokenApprovals[tokenId]`.
		assembly {
			approvedAddressSlot := tokenApproval.slot
			approvedAddress := sload(approvedAddressSlot)
		}
	}
	
	// =============================================================
	//                      TRANSFER OPERATIONS
	// =============================================================
	
	/**
	 * @dev Transfers `tokenId` from `from` to `to`.
     *
     * 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
	) public virtual override {
		uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);
		
		if (address(uint160(prevOwnershipPacked)) != from) revert TransferFromIncorrectOwner();
		
		(uint256 approvedAddressSlot, address approvedAddress) = _getApprovedSlotAndAddress(tokenId);
		
		// The nested ifs save around 20+ gas over a compound boolean condition.
		if (!_isSenderApprovedOrOwner(approvedAddress, from, _msgSenderERC721A()))
			if (!isApprovedForAll(from, _msgSenderERC721A())) revert TransferCallerNotOwnerNorApproved();
		
		if (to == address(0)) revert TransferToZeroAddress();
		
		_beforeTokenTransfers(from, to, tokenId, 1);
		
		// Clear approvals from the previous owner.
		assembly {
			if approvedAddress {
			// This is equivalent to `delete _tokenApprovals[tokenId]`.
				sstore(approvedAddressSlot, 0)
			}
		}
		
		// 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 {
		// We can directly increment and decrement the balances.
			--_packedAddressData[from]; // Updates: `balance -= 1`.
			++_packedAddressData[to]; // Updates: `balance += 1`.
		
		// Updates:
		// - `address` to the next owner.
		// - `startTimestamp` to the timestamp of transfering.
		// - `burned` to `false`.
		// - `nextInitialized` to `true`.
			_packedOwnerships[tokenId] = _packOwnershipData(
				to,
				_BITMASK_NEXT_INITIALIZED | _nextExtraData(from, to, prevOwnershipPacked)
			);
		
		// If the next slot may not have been initialized (i.e. `nextInitialized == false`) .
			if (prevOwnershipPacked & _BITMASK_NEXT_INITIALIZED == 0) {
				uint256 nextTokenId = tokenId + 1;
				// If the next slot's address is zero and not burned (i.e. packed value is zero).
				if (_packedOwnerships[nextTokenId] == 0) {
					// If the next slot is within bounds.
					if (nextTokenId != _currentIndex) {
						// Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.
						_packedOwnerships[nextTokenId] = prevOwnershipPacked;
					}
				}
			}
		}
		
		emit Transfer(from, to, tokenId);
		_afterTokenTransfers(from, to, tokenId, 1);
	}
	
	/**
	 * @dev Equivalent to `safeTransferFrom(from, to, tokenId, '')`.
     */
	function safeTransferFrom(
		address from,
		address to,
		uint256 tokenId
	) public virtual override {
		safeTransferFrom(from, to, tokenId, '');
	}
	
	/**
	 * @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 memory _data
	) public virtual override {
		transferFrom(from, to, tokenId);
		if (to.code.length != 0)
			if (!_checkContractOnERC721Received(from, to, tokenId, _data)) {
				revert TransferToNonERC721ReceiverImplementer();
			}
	}
	
	/**
	 * @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 {}