// Contract: CryptoCanyonHeroes
// Target function: function explicitOwnershipOf(uint256 tokenId) public view virtual override returns (TokenOwnership memory)
	
	// =============================================================
	//                        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
	// =============================================================
	
	/**
	 * @dev Directly sets the extra data for the ownership data `index`.
     */
	function _setExtraDataAt(uint256 index, uint24 extraData) internal virtual {
		uint256 packed = _packedOwnerships[index];
		if (packed == 0) revert OwnershipNotInitializedForExtraData();
		uint256 extraDataCasted;
		// Cast `extraData` with assembly to avoid redundant masking.
		assembly {
			extraDataCasted := extraData
		}
		packed = (packed & _BITMASK_EXTRA_DATA_COMPLEMENT) | (extraDataCasted << _BITPOS_EXTRA_DATA);
		_packedOwnerships[index] = packed;
	}
	
	/**
	 * @dev Called during each token transfer to set the 24bit `extraData` field.
     * Intended to be overridden by the cosumer contract.
     *
     * `previousExtraData` - the value of `extraData` before transfer.
     *
     * 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 _extraData(
		address from,
		address to,
		uint24 previousExtraData
	) internal view virtual returns (uint24) {}
	
	/**
	 * @dev Returns the next extra data for the packed ownership data.
     * The returned result is shifted into position.
     */
	function _nextExtraData(
		address from,
		address to,
		uint256 prevOwnershipPacked
	) private view returns (uint256) {
		uint24 extraData = uint24(prevOwnershipPacked >> _BITPOS_EXTRA_DATA);
		return uint256(_extraData(from, to, extraData)) << _BITPOS_EXTRA_DATA;
	}
	
	// =============================================================
	//                       OTHER OPERATIONS
	// =============================================================
	
	/**
	 * @dev Returns the message sender (defaults to `msg.sender`).
     *
     * If you are writing GSN compatible contracts, you need to override this function.
     */
	function _msgSenderERC721A() internal view virtual returns (address) {
		return msg.sender;
	}
	
	/**
	 * @dev Converts a uint256 to its ASCII string decimal representation.
     */
	function _toString(uint256 value) internal pure virtual returns (string memory str) {
		assembly {
		// The maximum value of a uint256 contains 78 digits (1 byte per digit),
		// but we allocate 0x80 bytes to keep the free memory pointer 32-byte word aliged.
		// We will need 1 32-byte word to store the length,
		// and 3 32-byte words to store a maximum of 78 digits. Total: 0x20 + 3 * 0x20 = 0x80.
			str := add(mload(0x40), 0x80)
		// Update the free memory pointer to allocate.
			mstore(0x40, str)
		
		// Cache the end of the memory to calculate the length later.
			let end := str
		
		// We write the string from rightmost digit to leftmost digit.
		// The following is essentially a do-while loop that also handles the zero case.
		// prettier-ignore
			for { let temp := value } 1 {} {
				str := sub(str, 1)
			// Write the character to the pointer.
			// The ASCII index of the '0' character is 48.
				mstore8(str, add(48, mod(temp, 10)))
			// Keep dividing `temp` until zero.
				temp := div(temp, 10)
			// prettier-ignore
				if iszero(temp) { break }
			}
			
			let length := sub(end, str)
		// Move the pointer 32 bytes leftwards to make room for the length.
			str := sub(str, 0x20)
		// Store the length.
			mstore(str, length)
		}
	}
}

/**
 * @dev Interface of ERC721AQueryable.
 */
interface IERC721AQueryable is IERC721A {
	/**
	 * Invalid query range (`start` >= `stop`).
	 */
	error InvalidQueryRange();
	
	/**
	 * @dev Returns the `TokenOwnership` struct at `tokenId` without reverting.
     *
     * If the `tokenId` is out of bounds:
     *
     * - `addr = address(0)`
     * - `startTimestamp = 0`
     * - `burned = false`
     * - `extraData = 0`
     *
     * If the `tokenId` is burned:
     *
     * - `addr = <Address of owner before token was burned>`
     * - `startTimestamp = <Timestamp when token was burned>`
     * - `burned = true`
     * - `extraData = <Extra data when token was burned>`
     *
     * Otherwise:
     *
     * - `addr = <Address of owner>`
     * - `startTimestamp = <Timestamp of start of ownership>`
     * - `burned = false`
     * - `extraData = <Extra data at start of ownership>`
     */
	function explicitOwnershipOf(uint256 tokenId) external view returns (TokenOwnership memory);
	
	/**
	 * @dev Returns an array of `TokenOwnership` structs at `tokenIds` in order.
     * See {ERC721AQueryable-explicitOwnershipOf}
     */
	function explicitOwnershipsOf(uint256[] memory tokenIds) external view returns (TokenOwnership[] memory);
	
	/**
	 * @dev Returns an array of token IDs owned by `owner`,
     * in the range [`start`, `stop`)
     * (i.e. `start <= tokenId < stop`).
     *
     * This function allows for tokens to be queried if the collection
     * grows too big for a single call of {ERC721AQueryable-tokensOfOwner}.
     *
     * Requirements:
     *
     * - `start < stop`
     */
	function tokensOfOwnerIn(
		address owner,
		uint256 start,
		uint256 stop
	) external view returns (uint256[] memory);
	
	/**
	 * @dev Returns an array of token IDs owned by `owner`.
     *
     * This function scans the ownership mapping and is O(`totalSupply`) in complexity.
     * It is meant to be called off-chain.
     *
     * See {ERC721AQueryable-tokensOfOwnerIn} for splitting the scan into
     * multiple smaller scans if the collection is large enough to cause
     * an out-of-gas error (10K collections should be fine).
     */
	function tokensOfOwner(address owner) external view returns (uint256[] memory);
}

/**
 * @title ERC721AQueryable.
 *
 * @dev ERC721A subclass with convenience query functions.
 */
abstract contract ERC721AQueryable is ERC721A, IERC721AQueryable {