// Contract: CryptoCanyonHeroes
// Target function: function _setExtraDataAt(uint256 index, uint24 extraData) internal virtual
)) != 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 {}
	
	/**
	 * @dev Private function to invoke {IERC721Receiver-onERC721Received} on a target contract.
     *
     * `from` - Previous owner of the given token ID.
     * `to` - Target address that will receive the token.
     * `tokenId` - Token ID to be transferred.
     * `_data` - Optional data to send along with the call.
     *
     * Returns whether the call correctly returned the expected magic value.
     */
	function _checkContractOnERC721Received(
		address from,
		address to,
		uint256 tokenId,
		bytes memory _data
	) private returns (bool) {
		try ERC721A__IERC721Receiver(to).onERC721Received(_msgSenderERC721A(), from, tokenId, _data) returns (
			bytes4 retval
		) {
			return retval == ERC721A__IERC721Receiver(to).onERC721Received.selector;
		} catch (bytes memory reason) {
			if (reason.length == 0) {
				revert TransferToNonERC721ReceiverImplementer();
			} else {
				assembly {
					revert(add(32, reason), mload(reason))
				}
			}
		}
	}
	
	// =============================================================
	//                        MINT OPERATIONS
	// =============================================================
	
	/**
	 * @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 for each mint.
     */
	function _mint(address to, uint256 quantity) internal virtual {
		uint256 startTokenId = _currentIndex;
		if (quantity == 0) revert MintZeroQuantity();
		
		_beforeTokenTransfers(address(0), to, startTokenId, quantity);
		
		// Overflows are incredibly unrealistic.
		// `balance` and `numberMinted` have a maximum limit of 2**64.
		// `tokenId` has a maximum limit of 2**256.
		unchecked {
		// Updates:
		// - `balance += quantity`.
		// - `numberMinted += quantity`.
		//
		// We can directly add to the `balance` and `numberMinted`.
			_packedAddressData[to] += quantity * ((1 << _BITPOS_NUMBER_MINTED) | 1);
		
		// Updates:
		// - `address` to the owner.
		// - `startTimestamp` to the timestamp of minting.
		// - `burned` to `false`.
		// - `nextInitialized` to `quantity == 1`.
			_packedOwnerships[startTokenId] = _packOwnershipData(
				to,
				_nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)
			);
			
			uint256 toMasked;
			uint256 end = startTokenId + quantity;
		
		// Use assembly to loop and emit the `Transfer` event for gas savings.
			assembly {
			// Mask `to` to the lower 160 bits, in case the upper bits somehow aren't clean.
				toMasked := and(to, _BITMASK_ADDRESS)
			// Emit the `Transfer` event.
				log4(
					0, // Start of data (0, since no data).
					0, // End of data (0, since no data).
					_TRANSFER_EVENT_SIGNATURE, // Signature.
					0, // `address(0)`.
					toMasked, // `to`.
					startTokenId // `tokenId`.
				)
				
				for {
					let tokenId := add(startTokenId, 1)
				} iszero(eq(tokenId, end)) {
					tokenId := add(tokenId, 1)
				} {
				// Emit the `Transfer` event. Similar to above.
					log4(0, 0, _TRANSFER_EVENT_SIGNATURE, 0, toMasked, tokenId)
				}
			}
			if (toMasked == 0) revert MintToZeroAddress();
			
			_currentIndex = end;
		}
		_afterTokenTransfers(address(0), to, startTokenId, quantity);
	}
	
	/**
	 * @dev Mints `quantity` tokens and transfers them to `to`.
     *
     * This function is intended for efficient minting only during contract creation.
     *
     * It emits only one {ConsecutiveTransfer} as defined in
     * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309),
     * instead of a sequence of {Transfer} event(s).
     *
     * Calling this function outside of contract creation WILL make your contract
     * non-compliant with the ERC721 standard.
     * For full ERC721 compliance, substituting ERC721 {Transfer} event(s) with the ERC2309
     * {ConsecutiveTransfer} event is only permissible during contract creation.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `quantity` must be greater than 0.
     *
     * Emits a {ConsecutiveTransfer} event.
     */
	function _mintERC2309(address to, uint256 quantity) internal virtual {
		uint256 startTokenId = _currentIndex;
		if (to == address(0)) revert MintToZeroAddress();
		if (quantity == 0) revert MintZeroQuantity();
		if (quantity > _MAX_MINT_ERC2309_QUANTITY_LIMIT) revert MintERC2309QuantityExceedsLimit();
		
		_beforeTokenTransfers(address(0), to, startTokenId, quantity);
		
		// Overflows are unrealistic due to the above check for `quantity` to be below the limit.
		unchecked {
		// Updates:
		// - `balance += quantity`.
		// - `numberMinted += quantity`.
		//
		// We can directly add to the `balance` and `numberMinted`.
			_packedAddressData[to] += quantity * ((1 << _BITPOS_NUMBER_MINTED) | 1);
		
		// Updates:
		// - `address` to the owner.
		// - `startTimestamp` to the timestamp of minting.
		// - `burned` to `false`.
		// - `nextInitialized` to `quantity == 1`.
			_packedOwnerships[startTokenId] = _packOwnershipData(
				to,
				_nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)
			);
			
			emit ConsecutiveTransfer(startTokenId, startTokenId + quantity - 1, address(0), to);
			
			_currentIndex = startTokenId + quantity;
		}
		_afterTokenTransfers(address(0), to, startTokenId, 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.
     *
     * See {_mint}.
     *
     * Emits a {Transfer} event for each mint.
     */
	function _safeMint(
		address to,
		uint256 quantity,
		bytes memory _data
	) internal virtual {
		_mint(to, quantity);
		
		unchecked {
			if (to.code.length != 0) {
				uint256 end = _currentIndex;
				uint256 index = end - quantity;
				do {
					if (!_checkContractOnERC721Received(address(0), to, index++, _data)) {
						revert TransferToNonERC721ReceiverImplementer();
					}
				} while (index < end);
				// Reentrancy protection.
				if (_currentIndex != end) revert();
			}
		}
	}
	
	/**
	 * @dev Equivalent to `_safeMint(to, quantity, '')`.
     */
	function _safeMint(address to, uint256 quantity) internal virtual {
		_safeMint(to, quantity, '');
	}
	
	// =============================================================
	//                        BURN OPERATIONS
	// =============================================================
	
	/**
	 * @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 {
		uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);
		
		address from = address(uint160(prevOwnershipPacked));
		
		(uint256 approvedAddressSlot, address approvedAddress) = _getApprovedSlotAndAddress(tokenId);
		
		if (approvalCheck) {
			// The nested ifs save around 20+ gas over a compound boolean condition.
			if (!_isSenderApprovedOrOwner(approvedAddress, from, _msgSenderERC721A()))
				if (!isApprovedForAll(from, _msgSenderERC721A())) revert TransferCallerNotOwnerNorApproved();
		}
		
		_beforeTokenTransfers(from, address(0), 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 {
		// Updates:
		// - `balance -= 1`.
		// - `numberBurned += 1`.
		//
		// We can directly decrement the balance, and increment the number burned.
		// This is equivalent to `packed -= 1; packed += 1 << _BITPOS_NUMBER_BURNED;`.
			_packedAddressData[from] += (1 << _BITPOS_NUMBER_BURNED) - 1;
		
		// Updates:
		// - `address` to the last owner.
		// - `startTimestamp` to the timestamp of burning.
		// - `burned` to `true`.
		// - `nextInitialized` to `true`.
			_packedOwnerships[tokenId] = _packOwnershipData(
				from,
				(_BITMASK_BURNED | _BITMASK_NEXT_INITIALIZED) | _nextExtraData(from, address(0), 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, address(0), tokenId);
		_afterTokenTransfers(from, address(0), tokenId, 1);
		
		// Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.
		unchecked {
			_burnCounter++;
		}
	}
	
	// =============================================================
	//                     EXTRA DATA OPERATIONS
	// =============================================================