// Contract: CryptoCanyonHeroes
// Target function: function transferFrom(
	// The bit position of the `nextInitialized` bit in packed ownership.
	uint256 private constant _BITPOS_NEXT_INITIALIZED = 225;
	
	// The bit mask of the `nextInitialized` bit in packed ownership.
	uint256 private constant _BITMASK_NEXT_INITIALIZED = 1 << 225;
	
	// The bit position of `extraData` in packed ownership.
	uint256 private constant _BITPOS_EXTRA_DATA = 232;
	
	// Mask of all 256 bits in a packed ownership except the 24 bits for `extraData`.
	uint256 private constant _BITMASK_EXTRA_DATA_COMPLEMENT = (1 << 232) - 1;
	
	// The mask of the lower 160 bits for addresses.
	uint256 private constant _BITMASK_ADDRESS = (1 << 160) - 1;
	
	// The maximum `quantity` that can be minted with {_mintERC2309}.
	// This limit is to prevent overflows on the address data entries.
	// For a limit of 5000, a total of 3.689e15 calls to {_mintERC2309}
	// is required to cause an overflow, which is unrealistic.
	uint256 private constant _MAX_MINT_ERC2309_QUANTITY_LIMIT = 5000;
	
	// The `Transfer` event signature is given by:
	// `keccak256(bytes("Transfer(address,address,uint256)"))`.
	bytes32 private constant _TRANSFER_EVENT_SIGNATURE =
	0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;
	
	// =============================================================
	//                            STORAGE
	// =============================================================
	
	// The next token ID to be minted.
	uint256 private _currentIndex;
	
	// The number of tokens burned.
	uint256 private _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 {_packedOwnershipOf} implementation for details.
	//
	// Bits Layout:
	// - [0..159]   `addr`
	// - [160..223] `startTimestamp`
	// - [224]      `burned`
	// - [225]      `nextInitialized`
	// - [232..255] `extraData`
	mapping(uint256 => uint256) private _packedOwnerships;
	
	// Mapping owner address to address data.
	//
	// Bits Layout:
	// - [0..63]    `balance`
	// - [64..127]  `numberMinted`
	// - [128..191] `numberBurned`
	// - [192..255] `aux`
	mapping(address => uint256) private _packedAddressData;
	
	// Mapping from token ID to approved address.
	mapping(uint256 => TokenApprovalRef) private _tokenApprovals;
	
	// Mapping from owner to operator approvals
	mapping(address => mapping(address => bool)) private _operatorApprovals;
	
	// =============================================================
	//                          CONSTRUCTOR
	// =============================================================
	
	constructor(string memory name_, string memory symbol_) {
		_name = name_;
		_symbol = symbol_;
		_currentIndex = _startTokenId();
	}
	
	// =============================================================
	//                   TOKEN COUNTING OPERATIONS
	// =============================================================
	
	/**
	 * @dev Returns the starting token ID.
     * To change the starting token ID, please override this function.
     */
	function _startTokenId() internal view virtual returns (uint256) {
		return 1;
	}
	
	/**
	 * @dev Returns the next token ID to be minted.
     */
	function _nextTokenId() internal view virtual returns (uint256) {
		return _currentIndex;
	}
	
	/**
	 * @dev Returns the total number of tokens in existence.
     * Burned tokens will reduce the count.
     * To get the total number of tokens minted, please see {_totalMinted}.
     */
	function totalSupply() public view virtual override returns (uint256) {
		// Counter underflow is impossible as _burnCounter cannot be incremented
		// more than `_currentIndex - _startTokenId()` times.
		unchecked {
			return _currentIndex - _burnCounter - _startTokenId();
		}
	}
	
	/**
	 * @dev Returns the total amount of tokens minted in the contract.
     */
	function _totalMinted() internal view virtual returns (uint256) {
		// Counter underflow is impossible as `_currentIndex` does not decrement,
		// and it is initialized to `_startTokenId()`.
		unchecked {
			return _currentIndex - _startTokenId();
		}
	}
	
	/**
	 * @dev Returns the total number of tokens burned.
     */
	function _totalBurned() internal view virtual returns (uint256) {
		return _burnCounter;
	}
	
	// =============================================================
	//                    ADDRESS DATA OPERATIONS
	// =============================================================
	
	/**
	 * @dev Returns the number of tokens in `owner`'s account.
     */
	function balanceOf(address owner) public view virtual override returns (uint256) {
		if (owner == address(0)) revert BalanceQueryForZeroAddress();
		return _packedAddressData[owner] & _BITMASK_ADDRESS_DATA_ENTRY;
	}
	
	/**
	 * Returns the number of tokens minted by `owner`.
	 */
	function _numberMinted(address owner) internal view returns (uint256) {
		return (_packedAddressData[owner] >> _BITPOS_NUMBER_MINTED) & _BITMASK_ADDRESS_DATA_ENTRY;
	}
	
	/**
	 * Returns the number of tokens burned by or on behalf of `owner`.
	 */
	function _numberBurned(address owner) internal view returns (uint256) {
		return (_packedAddressData[owner] >> _BITPOS_NUMBER_BURNED) & _BITMASK_ADDRESS_DATA_ENTRY;
	}
	
	/**
	 * Returns the auxiliary data for `owner`. (e.g. number of whitelist mint slots used).
	 */
	function _getAux(address owner) internal view returns (uint64) {
		return uint64(_packedAddressData[owner] >> _BITPOS_AUX);
	}
	
	/**
	 * Sets the auxiliary 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 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
	// =============================================================