// Contract: MBMSFY
// Target function: function safeTransferFrom(
` 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
		) external;

		/**
		 * @dev Transfers `tokenId` token 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;

		/**
		 * @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;

		/**
		 * @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);
}


/**
 * @dev ERC721 token receiver interface.
 */
interface ERC721A__IERC721Receiver {
		function onERC721Received(
				address operator,
				address from,
				uint256 tokenId,
				bytes calldata data
		) external returns (bytes4);
}

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension. Built to optimize for lower gas during batch mints.
 *
 * Assumes serials are sequentially minted starting at _startTokenId() (defaults to 0, e.g. 0, 1, 2, 3..).
 *
 * Assumes that an owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
 *
 * Assumes that the maximum token id cannot exceed 2**256 - 1 (max value of uint256).
 */
contract ERC721A is IERC721A {
		// 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 tokenId of the next token 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`
		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 => address) private _tokenApprovals;

		// Mapping from owner to operator approvals
		mapping(address => mapping(address => bool)) private _operatorApprovals;

		constructor(string memory name_, string memory symbol_) {
				_name = name_;
				_symbol = symbol_;
				_currentIndex = _startTokenId();
		}

		/**
		 * @dev Returns the starting token ID. 
		 * To change the starting token ID, please override this function.
		 */
		function _startTokenId() internal view virtual returns (uint256) {
				return 0;
		}

		/**
		 * @dev Returns the next token ID to be minted.
		 */
		function _nextTokenId() internal view 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 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 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 returns (uint256) {
				return _burnCounter;
		}

		/**
		 * @dev See {IERC165-supportsInterface}.
		 */
		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: 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.
		}

		/**
		 * @dev See {IERC721-balanceOf}.
		 */
		function balanceOf(address owner) public view 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 auxillary 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 auxillary 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 {
				uint256 packed = _packedAddressData[owner];
				uint256 auxCasted;
				assembly { // Cast aux without masking.
						auxCasted := aux
				}
				packed = (packed & BITMASK_AUX_COMPLEMENT) | (auxCasted << BITPOS_AUX);
				_packedAddressData[owner] = packed;
		}

		/**
		 * 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 ownership that has an address and is not burned
												// before an ownership that does not have an address and is not burned.
												// Hence, curr will not underflow.
												//
												// We can directly compare the packed value.
												// If the address is zero, packed is zero.
												while (packed == 0) {
														packed = _packedOwnerships[--curr];
												}
												return packed;
										}
								}
				}
				revert OwnerQueryForNonexistentToken();
		}

		/**
		 * 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;
		}

		/**
		 * Returns the unpacked `TokenOwnership` struct at `index`.
		 */
		function _ownershipAt(uint256 index) internal view returns (TokenOwnership memory) {
				return _unpackedOwnership(_packedOwnerships[index]);
		}

		/**
		 * @dev Initializes the ownership slot minted at `index` for efficiency purposes.
		 */
		function _initializeOwnershipAt(uint256 index) internal {
				if (_packedOwnerships[index] == 0) {
						_packedOwnerships[index] = _packedOwnershipOf(index);
				}
		}

		/**
		 * Gas spent here starts off proportional to the maximum mint batch size.
		 * It gradually moves to O(1) as tokens get transferred around in the collection over time.
		 */
		function _ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
				return _unpackedOwnership(_packedOwnershipOf(tokenId));
		}

		/**
		 * @dev See {IERC721-ownerOf}.
		 */
		function ownerOf(uint256 tokenId) public view override returns (address) {
				return address(uint160(_packedOwnershipOf(tokenId)));
		}

		/**
		 * @dev See {IERC721Metadata-name}.
		 */
		function name() public view virtual override returns (string memory) {
				return _name;
		}

		/**
		 * @dev See {IERC721Metadata-symbol}.
		 */
		function symbol() public view virtual override returns (string memory) {
				return _symbol;
		}

		/**
		 * @dev See {IERC721Metadata-tokenURI}.
		 */
		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, can be overriden in child contracts.
		 */
		function _baseURI() internal view virtual returns (string memory) {
				return '';
		}

		/**
		 * @dev Casts the address to uint256 without masking.
		 */
		function _addressToUint256(address value) private pure returns (uint256 result) {
				assembly {
						result := value
				}
		}

		/**
		 * @dev Casts the boolean to uint256 without branching.
		 */
		function _boolToUint256(bool value) private pure returns (uint256 result) {
				assembly {
						result := value
				}
		}

		/**
		 * @dev See {IERC721-approve}.
		 */
		function approve(address to, uint256 tokenId) public override {
				address owner = address(uint160(_packedOwnershipOf(tokenId)));
				if (to == owner) revert ApprovalToCurrentOwner();

				if (_msgSenderERC721A() != owner)
						if (!isApprovedForAll(owner, _msgSenderERC721A())) {
								revert ApprovalCallerNotOwnerNorApproved();
						}

				_tokenApprovals[tokenId] = to;
				emit Approval(owner, to, tokenId);
		}

		/**
		 * @dev See {IERC721-getApproved}.
		 */
		function getApproved(uint256 tokenId) public view override returns (address) {
				if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();

				return _tokenApprovals[tokenId];
		}

		/**
		 * @dev See {IERC721-setApprovalForAll}.
		 */
		function setApprovalForAll(address operator, bool approved) public virtual override {
				if (operator == _msgSenderERC721A()) revert ApproveToCaller();

				_operatorApprovals[_msgSenderERC721A()][operator] = approved;
				emit ApprovalForAll(_msgSenderERC721A(), operator, approved);
		}

		/**
		 * @dev See {IERC721-isApprovedForAll}.
		 */
		function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
				return _operatorApprovals[owner][operator];
		}

		/**
		 * @dev See {IERC721-transferFrom}.
		 */
		function transferFrom(
				address from,
				address to,
				uint256 tokenId
		) public virtual override {
				_transfer(from, to, tokenId);
		}