// Contract: CryptoCanyonHeroes
// Target function: function approve(address to, uint256 tokenId) public virtual override
 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);
	
	// =============================================================
	//                        IERC721Metadata
	// =============================================================
	
	/**
	 * @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);
	
	// =============================================================
	//                           IERC2309
	// =============================================================
	
	/**
	 * @dev Emitted when tokens in `fromTokenId` to `toTokenId`
     * (inclusive) is transferred from `from` to `to`, as defined in the
     * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309) standard.
     *
     * See {_mintERC2309} for more details.
     */
	event ConsecutiveTransfer(uint256 indexed fromTokenId, uint256 toTokenId, address indexed from, address indexed to);
}
/**
 * @dev Interface of ERC721 token receiver.
 */
interface ERC721A__IERC721Receiver {
	function onERC721Received(
		address operator,
		address from,
		uint256 tokenId,
		bytes calldata data
	) external returns (bytes4);
}

/**
 * @title ERC721A
 *
 * @dev Implementation of the [ERC721](https://eips.ethereum.org/EIPS/eip-721)
 * Non-Fungible Token Standard, including the Metadata extension.
 * Optimized for lower gas during batch mints.
 *
 * Token IDs are minted in sequential order (e.g. 0, 1, 2, 3, ...)
 * starting from `_startTokenId()`.
 *
 * Assumptions:
 *
 * - An owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
 * - The maximum token ID cannot exceed 2**256 - 1 (max value of uint256).
 */
contract ERC721A is IERC721A{
	// Reference type for token approval.
	struct TokenApprovalRef {
		address value;
	}
	
	// =============================================================
	//                           CONSTANTS
	// =============================================================
	
	// Mask of an entry in packed address data.
	uint256 private constant _BITMASK_ADDRESS_DATA_ENTRY = (1 << 64) - 1;
	
	// The bit position of `numberMinted` in packed address data.
	uint256 private constant _BITPOS_NUMBER_MINTED = 64;
	
	// The bit position of `numberBurned` in packed address data.
	uint256 private constant _BITPOS_NUMBER_BURNED = 128;
	
	// The bit position of `aux` in packed address data.
	uint256 private constant _BITPOS_AUX = 192;
	
	// Mask of all 256 bits in packed address data except the 64 bits for `aux`.
	uint256 private constant _BITMASK_AUX_COMPLEMENT = (1 << 192) - 1;
	
	// The bit position of `startTimestamp` in packed ownership.
	uint256 private constant _BITPOS_START_TIMESTAMP = 160;
	
	// The bit mask of the `burned` bit in packed ownership.
	uint256 private constant _BITMASK_BURNED = 1 << 224;
	
	// 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
	// =============================================================