// Contract: Gunx
// Target function: function _unpackedOwnership(uint256 packed) private pure returns (TokenOwnership memory ownership)
 indexed to, uint256 indexed tokenId);

/**
 * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
 */
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

/**
 * @dev Emitted when `owner` enables or disables
 * (`approved`) `operator` to manage all of its assets.
 */
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

/**
 * @dev Returns the number of tokens in `owner`'s account.
 */
function balanceOf(address owner) external view returns (uint256 balance);

/**
 * @dev Returns the owner of the `tokenId` token.
 *
 * Requirements:
 *
 * - `tokenId` must exist.
 */
function ownerOf(uint256 tokenId) external view returns (address owner);

/**
 * @dev Safely transfers `tokenId` token from `from` to `to`,
 * checking first that contract recipients are aware of the ERC721 protocol
 * to prevent tokens from being forever locked.
 *
 * 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 have been allowed 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 calldata data
) external payable;

/**
 * @dev Equivalent to `safeTransferFrom(from, to, tokenId, '')`.
 */
function safeTransferFrom(
	address from,
	address to,
	uint256 tokenId
) external payable;

/**
 * @dev Transfers `tokenId` from `from` to `to`.
 *
 * WARNING: Usage of this method is discouraged, use {safeTransferFrom}
 * whenever possible.
 *
 * 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
) external payable;

/**
 * @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) external payable;

/**
 * @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) 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 {
// Bypass for a `--via-ir` bug (https://github.com/chiru-labs/ERC721A/pull/364).
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() {
	_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 '';
}


function symbol() public view virtual override returns (string memory) {
	return '';
}



/**
 * @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('ipfs://', baseURI, '/', _toString(tokenId), '.json')) : '';
}

/**
 * @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();
}