// Contract: Gunx
// Target function: function _setExtraDataAt(uint256 index, uint24 extraData) internal virtual
 tokenApproval = _tokenApprovals[tokenId];
	// The following is equivalent to `approvedAddress = _tokenApprovals[tokenId].value`.
	assembly {
		approvedAddressSlot := tokenApproval.slot
		approvedAddress := sload(approvedAddressSlot)
	}
}

// =============================================================
//                      TRANSFER OPERATIONS
// =============================================================

/**
 * @dev Transfers `tokenId` from `from` to `to`.
 *
 * 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
) public payable virtual override {
	uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);

	if (address(uint160(prevOwnershipPacked)) != 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 payable 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 payable 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.
		// The duplicated `log4` removes an extra check and reduces stack juggling.
		// The assembly, together with the surrounding Solidity code, have been
		// delicately arranged to nudge the compiler into producing optimized opcodes.
		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`.
			)

			// The `iszero(eq(,))` check ensures that large values of `quantity`
			// that overflows uint256 will make the loop run out of gas.
			// The compiler will optimize the `iszero` away for performance.
			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
// =============================================================


function _burn(uint256 tokenId) internal virtual {
	_burn(tokenId, false);
}

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
// =============================================================