Code for 0xb325…f133 (ERC721)

Since block 14928080

Verified contract

{{
  "language": "Solidity",
  "sources": {
    "/contracts/ERC721.sol": {
      "content": "// SPDX-License-Identifier: AGPL-3.0\n\npragma solidity ^0.8.9;\n\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\nimport \"@openzeppelin/contracts/finance/PaymentSplitter.sol\";\nimport \"@openzeppelin/contracts/security/Pausable.sol\";\nimport \"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\";\nimport \"./external/ERC721AWithRoyalties.sol\";\n\n// @author rollauver.eth\n\ncontract ERC721 is Ownable, ERC721AWithRoyalties, Pausable, PaymentSplitter {\n  string public _baseTokenURI;\n\n  bytes32 public _merkleRoot;\n\n  uint256 public _price;\n  uint256 public _presalePrice;\n  uint256 public _maxSupply;\n  uint256 public _maxPerAddress;\n  uint256 public _presaleMaxPerAddress;\n  uint256 public _publicSaleTime;\n  uint256 public _preSaleTime;\n  uint256 public _maxTxPerAddress;\n  mapping(address => uint256) private _purchases;\n\n  event EarlyPurchase(address indexed addr, uint256 indexed atPrice, uint256 indexed count);\n  event Purchase(address indexed addr, uint256 indexed atPrice, uint256 indexed count);\n\n  constructor(\n    string memory name,\n    string memory symbol,\n    string memory baseTokenURI, // baseTokenURI - 0\n    uint256[] memory numericValues, // price - 0, presalePrice - 1, maxSupply - 2, maxPerAddress - 3, presaleMaxPerAddress - 4, publicSaleTime - 5, _preSaleTime - 6, _maxTxPerAddress - 7\n    bytes32 merkleRoot,\n    address[] memory payees,\n    uint256[] memory shares,\n    address royaltyRecipient,\n    uint256 royaltyAmount\n  ) ERC721AWithRoyalties(name, symbol, numericValues[2], royaltyRecipient, royaltyAmount) PaymentSplitter(payees, shares) {\n    _baseTokenURI = baseTokenURI;\n\n    _price = numericValues[0];\n    _presalePrice = numericValues[1];\n    _maxSupply = numericValues[2];\n    _maxPerAddress = numericValues[3];\n    _presaleMaxPerAddress = numericValues[4];\n    _publicSaleTime = numericValues[5];\n    _preSaleTime = numericValues[6];\n    _maxTxPerAddress = numericValues[7];\n\n    _merkleRoot = merkleRoot;\n  }\n\n  function setSaleInformation(\n    uint256 publicSaleTime,\n    uint256 preSaleTime,\n    uint256 maxPerAddress,\n    uint256 presaleMaxPerAddress,\n    uint256 price,\n    uint256 presalePrice,\n    bytes32 merkleRoot,\n    uint256 maxTxPerAddress\n  ) external onlyOwner {\n    _publicSaleTime = publicSaleTime;\n    _preSaleTime = preSaleTime;\n    _maxPerAddress = maxPerAddress;\n    _presaleMaxPerAddress = presaleMaxPerAddress;\n    _price = price;\n    _presalePrice = presalePrice;\n    _merkleRoot = merkleRoot;\n    _maxTxPerAddress = maxTxPerAddress;\n  }\n\n  function setBaseUri(\n    string memory baseUri\n  ) external onlyOwner {\n    _baseTokenURI = baseUri;\n  }\n\n  function setMerkleRoot(bytes32 merkleRoot) external onlyOwner {\n    _merkleRoot = merkleRoot;\n  }\n\n  function _baseURI() override internal view virtual returns (string memory) {\n    return string(\n      abi.encodePacked(\n        _baseTokenURI,\n        Strings.toHexString(uint256(uint160(address(this))), 20),\n        '/'\n      )\n    );\n  }\n\n  function mint(address to, uint256 count) external payable onlyOwner {\n    ensureMintConditions(count);\n\n    _safeMint(to, count);\n  }\n\n  function purchase(uint256 count) external payable whenNotPaused {\n    ensurePublicMintConditions(msg.sender, count, _maxPerAddress);\n    require(isPublicSaleActive(), \"BASE_COLLECTION/CANNOT_MINT\");\n\n    _purchase(count, _price);\n    emit Purchase(msg.sender, _price, count);\n  }\n\n  function earlyPurchase(uint256 count, bytes32[] calldata merkleProof) external payable whenNotPaused {\n    ensurePublicMintConditions(msg.sender, count, _presaleMaxPerAddress);\n    require(isPreSaleActive() && onEarlyPurchaseList(msg.sender, merkleProof), \"BASE_COLLECTION/CANNOT_MINT_PRESALE\");\n\n    _purchase(count, _presalePrice);\n    emit EarlyPurchase(msg.sender, _presalePrice, count);\n  }\n\n  function _purchase(uint256 count, uint256 price) private {\n    require(price * count <= msg.value, 'BASE_COLLECTION/INSUFFICIENT_ETH_AMOUNT');\n\n    _purchases[msg.sender] += count;\n    _safeMint(msg.sender, count);\n  }\n\n  function ensureMintConditions(uint256 count) internal view {\n    require(totalSupply() + count <= _maxSupply, \"BASE_COLLECTION/EXCEEDS_MAX_SUPPLY\");\n  }\n\n  function ensurePublicMintConditions(address to, uint256 count, uint256 maxPerAddress) internal view {\n    ensureMintConditions(count);\n\n    require((_maxTxPerAddress == 0) || (count <= _maxTxPerAddress), \"BASE_COLLECTION/EXCEEDS_MAX_PER_TRANSACTION\");\n    uint256 totalMintFromAddress = _purchases[to] + count;\n    require ((maxPerAddress == 0) || (totalMintFromAddress <= maxPerAddress), \"BASE_COLLECTION/EXCEEDS_INDIVIDUAL_SUPPLY\");\n  }\n\n  function isPublicSaleActive() public view returns (bool) {\n    return (_publicSaleTime == 0 || _publicSaleTime < block.timestamp);\n  }\n\n  function isPreSaleActive() public view returns (bool) {\n    return (_preSaleTime == 0 || (_preSaleTime < block.timestamp) && (block.timestamp < _publicSaleTime));\n  }\n\n  function onEarlyPurchaseList(address addr, bytes32[] calldata merkleProof) public view returns (bool) {\n    require(_merkleRoot.length > 0, \"BASE_COLLECTION/PRESALE_MINT_LIST_UNSET\");\n\n    bytes32 node = keccak256(abi.encodePacked(addr));\n    return MerkleProof.verify(merkleProof, _merkleRoot, node);\n  }\n\n  function MAX_TOTAL_MINT() public view returns (uint256) {\n    return _maxSupply;\n  }\n\n  function PRICE() public view returns (uint256) {\n    if (isPreSaleActive()) {\n      return _presalePrice;\n    }\n\n    return _price;\n  }\n\n  function MAX_TOTAL_MINT_PER_ADDRESS() public view returns (uint256) {\n    if (isPreSaleActive()) {\n      return _presaleMaxPerAddress;\n    }\n\n    return _maxPerAddress;\n  }\n\n  function pause() external onlyOwner {\n    _pause();\n  }\n\n  function unpause() external onlyOwner {\n    _unpause();\n  }\n}\n"
    },
    "/contracts/external/IERC2981Royalties.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @title IERC2981Royalties\n/// @dev Interface for the ERC2981 - Token Royalty standard\ninterface IERC2981Royalties {\n  /// @notice Called with the sale price to determine how much royalty\n  //          is owed and to whom.\n  /// @param _tokenId - the NFT asset queried for royalty information\n  /// @param _value - the sale price of the NFT asset specified by _tokenId\n  /// @return _receiver - address of who should be sent the royalty payment\n  /// @return _royaltyAmount - the royalty payment amount for value sale price\n  function royaltyInfo(uint256 _tokenId, uint256 _value)\n    external\n    view\n    returns (address _receiver, uint256 _royaltyAmount);\n}\n"
    },
    "/contracts/external/ERC721AWithRoyalties.sol": {
      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.9;\n\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\nimport \"./ERC721A.sol\";\nimport \"./IERC2981Royalties.sol\";\n\n// @author rollauver.eth\n\ncontract ERC721AWithRoyalties is\n  Ownable,\n  ERC721A,\n  IERC2981Royalties\n{\n  struct RoyaltyInfo {\n    address recipient;\n    uint24 amount;\n  }\n  RoyaltyInfo private _royalties;\n\n  constructor(\n    string memory name_,\n    string memory symbol_,\n    uint256 maxBatchSize_,\n    address royaltyRecipient,\n    uint256 royaltyValue\n  ) ERC721A(name_, symbol_, maxBatchSize_) {\n    _setRoyalties(royaltyRecipient, royaltyValue);\n  }\n  \n  /// @inheritdoc ERC165\n  function supportsInterface(bytes4 interfaceId)\n    public\n    view\n    virtual\n    override\n    returns (bool)\n  {\n    return\n      interfaceId == type(IERC2981Royalties).interfaceId ||\n      super.supportsInterface(interfaceId);\n  }\n\n  /// @dev Sets token royalties\n  /// @param recipient recipient of the royalties\n  /// @param value percentage (using 2 decimals - 10000 = 100, 0 = 0)\n  function _setRoyalties(address recipient, uint256 value) internal {\n    require(value <= 10000, 'ERC2981Royalties: Too high');\n    _royalties = RoyaltyInfo(recipient, uint24(value));\n  }\n\n  /// @inheritdoc IERC2981Royalties\n  function royaltyInfo(uint256, uint256 value)\n    external\n    view\n    override\n    returns (address receiver, uint256 royaltyAmount)\n  {\n    RoyaltyInfo memory royalties = _royalties;\n    receiver = royalties.recipient;\n    royaltyAmount = (value * royalties.amount) / 10000;\n  }\n\n  function updateRoyalties(address recipient, uint256 value) external onlyOwner {\n    _setRoyalties(recipient, value);\n  }\n}\n"
    },
    "/contracts/external/ERC721A.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// Creators: locationtba.eth, 2pmflow.eth\n\npragma solidity ^0.8.0;\n\nimport \"@openzeppelin/contracts/token/ERC721/IERC721.sol\";\nimport \"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol\";\nimport \"@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol\";\nimport \"@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol\";\nimport \"@openzeppelin/contracts/utils/Address.sol\";\nimport \"@openzeppelin/contracts/utils/Context.sol\";\nimport \"@openzeppelin/contracts/utils/Strings.sol\";\nimport \"@openzeppelin/contracts/utils/introspection/ERC165.sol\";\n\n/**\n * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including\n * the Metadata and Enumerable extension. Built to optimize for lower gas during batch mints.\n *\n * Assumes serials are sequentially minted starting at 0 (e.g. 0, 1, 2, 3..).\n *\n * Does not support burning tokens to address(0).\n */\ncontract ERC721A is\n  Context,\n  ERC165,\n  IERC721,\n  IERC721Metadata,\n  IERC721Enumerable\n{\n  using Address for address;\n  using Strings for uint256;\n\n  struct TokenOwnership {\n    address addr;\n    uint64 startTimestamp;\n  }\n\n  struct AddressData {\n    uint128 balance;\n    uint128 numberMinted;\n  }\n\n  uint256 private currentIndex = 1;\n\n  uint256 internal immutable maxBatchSize;\n\n  // Token name\n  string private _name;\n\n  // Token symbol\n  string private _symbol;\n\n  // Mapping from token ID to ownership details\n  // An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.\n  mapping(uint256 => TokenOwnership) private _ownerships;\n\n  // Mapping owner address to address data\n  mapping(address => AddressData) private _addressData;\n\n  // Mapping from token ID to approved address\n  mapping(uint256 => address) private _tokenApprovals;\n\n  // Mapping from owner to operator approvals\n  mapping(address => mapping(address => bool)) private _operatorApprovals;\n\n  /**\n   * @dev\n   * `maxBatchSize` refers to how much a minter can mint at a time.\n   */\n  constructor(\n    string memory name_,\n    string memory symbol_,\n    uint256 maxBatchSize_\n  ) {\n    require(maxBatchSize_ > 0, \"ERC721A: max batch size must be nonzero\");\n    _name = name_;\n    _symbol = symbol_;\n    maxBatchSize = maxBatchSize_;\n  }\n\n  /**\n   * @dev See {IERC721Enumerable-totalSupply}.\n   */\n  function totalSupply() public view override returns (uint256) {\n    return currentIndex - 1;\n  }\n\n  /**\n   * @dev See {IERC721Enumerable-tokenByIndex}.\n   */\n  function tokenByIndex(uint256 index) public view override returns (uint256) {\n    require(index < totalSupply(), \"ERC721A: global index out of bounds\");\n    return index;\n  }\n\n  /**\n   * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.\n   * This read function is O(totalSupply). If calling from a separate contract, be sure to test gas first.\n   * It may also degrade with extremely large collection sizes (e.g >> 10000), test for your use case.\n   */\n  function tokenOfOwnerByIndex(address owner, uint256 index)\n    public\n    view\n    override\n    returns (uint256)\n  {\n    require(index < balanceOf(owner), \"ERC721A: owner index out of bounds\");\n    uint256 numMintedSoFar = totalSupply();\n    uint256 tokenIdsIdx = 0;\n    address currOwnershipAddr = address(0);\n    for (uint256 i = 0; i < numMintedSoFar; i++) {\n      TokenOwnership memory ownership = _ownerships[i];\n      if (ownership.addr != address(0)) {\n        currOwnershipAddr = ownership.addr;\n      }\n      if (currOwnershipAddr == owner) {\n        if (tokenIdsIdx == index) {\n          return i;\n        }\n        tokenIdsIdx++;\n      }\n    }\n    revert(\"ERC721A: unable to get token of owner by index\");\n  }\n\n  /**\n   * @dev See {IERC165-supportsInterface}.\n   */\n  function supportsInterface(bytes4 interfaceId)\n    public\n    view\n    virtual\n    override(ERC165, IERC165)\n    returns (bool)\n  {\n    return\n      interfaceId == type(IERC721).interfaceId ||\n      interfaceId == type(IERC721Metadata).interfaceId ||\n      interfaceId == type(IERC721Enumerable).interfaceId ||\n      super.supportsInterface(interfaceId);\n  }\n\n  /**\n   * @dev See {IERC721-balanceOf}.\n   */\n  function balanceOf(address owner) public view override returns (uint256) {\n    require(owner != address(0), \"ERC721A: balance query for the zero address\");\n    return uint256(_addressData[owner].balance);\n  }\n\n  function _numberMinted(address owner) internal view returns (uint256) {\n    require(\n      owner != address(0),\n      \"ERC721A: number minted query for the zero address\"\n    );\n    return uint256(_addressData[owner].numberMinted);\n  }\n\n  function ownershipOf(uint256 tokenId)\n    internal\n    view\n    returns (TokenOwnership memory)\n  {\n    require(_exists(tokenId), \"ERC721A: owner query for nonexistent token\");\n\n    uint256 lowestTokenToCheck;\n    if (tokenId >= maxBatchSize) {\n      lowestTokenToCheck = tokenId - maxBatchSize + 1;\n    }\n\n    for (uint256 curr = tokenId; curr >= lowestTokenToCheck; curr--) {\n      TokenOwnership memory ownership = _ownerships[curr];\n      if (ownership.addr != address(0)) {\n        return ownership;\n      }\n    }\n\n    revert(\"ERC721A: unable to determine the owner of token\");\n  }\n\n  /**\n   * @dev See {IERC721-ownerOf}.\n   */\n  function ownerOf(uint256 tokenId) public view override returns (address) {\n    return ownershipOf(tokenId).addr;\n  }\n\n  /**\n   * @dev See {IERC721Metadata-name}.\n   */\n  function name() public view virtual override returns (string memory) {\n    return _name;\n  }\n\n  /**\n   * @dev See {IERC721Metadata-symbol}.\n   */\n  function symbol() public view virtual override returns (string memory) {\n    return _symbol;\n  }\n\n  /**\n   * @dev See {IERC721Metadata-tokenURI}.\n   */\n  function tokenURI(uint256 tokenId)\n    public\n    view\n    virtual\n    override\n    returns (string memory)\n  {\n    require(\n      _exists(tokenId),\n      \"ERC721Metadata: URI query for nonexistent token\"\n    );\n\n    string memory baseURI = _baseURI();\n    return\n      bytes(baseURI).length > 0\n        ? string(abi.encodePacked(baseURI, tokenId.toString()))\n        : \"\";\n  }\n\n  /**\n   * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each\n   * token will be the concatenation of the `baseURI` and the `tokenId`. Empty\n   * by default, can be overriden in child contracts.\n   */\n  function _baseURI() internal view virtual returns (string memory) {\n    return \"\";\n  }\n\n  /**\n   * @dev See {IERC721-approve}.\n   */\n  function approve(address to, uint256 tokenId) public override {\n    address owner = ERC721A.ownerOf(tokenId);\n    require(to != owner, \"ERC721A: approval to current owner\");\n\n    require(\n      _msgSender() == owner || isApprovedForAll(owner, _msgSender()),\n      \"ERC721A: approve caller is not owner nor approved for all\"\n    );\n\n    _approve(to, tokenId, owner);\n  }\n\n  /**\n   * @dev See {IERC721-getApproved}.\n   */\n  function getApproved(uint256 tokenId) public view override returns (address) {\n    require(_exists(tokenId), \"ERC721A: approved query for nonexistent token\");\n\n    return _tokenApprovals[tokenId];\n  }\n\n  /**\n   * @dev See {IERC721-setApprovalForAll}.\n   */\n  function setApprovalForAll(address operator, bool approved) public override {\n    require(operator != _msgSender(), \"ERC721A: approve to caller\");\n\n    _operatorApprovals[_msgSender()][operator] = approved;\n    emit ApprovalForAll(_msgSender(), operator, approved);\n  }\n\n  /**\n   * @dev See {IERC721-isApprovedForAll}.\n   */\n  function isApprovedForAll(address owner, address operator)\n    public\n    view\n    virtual\n    override\n    returns (bool)\n  {\n    return _operatorApprovals[owner][operator];\n  }\n\n  /**\n   * @dev See {IERC721-transferFrom}.\n   */\n  function transferFrom(\n    address from,\n    address to,\n    uint256 tokenId\n  ) public override {\n    _transfer(from, to, tokenId);\n  }\n\n  /**\n   * @dev See {IERC721-safeTransferFrom}.\n   */\n  function safeTransferFrom(\n    address from,\n    address to,\n    uint256 tokenId\n  ) public override {\n    safeTransferFrom(from, to, tokenId, \"\");\n  }\n\n  /**\n   * @dev See {IERC721-safeTransferFrom}.\n   */\n  function safeTransferFrom(\n    address from,\n    address to,\n    uint256 tokenId,\n    bytes memory _data\n  ) public override {\n    _transfer(from, to, tokenId);\n    require(\n      _checkOnERC721Received(from, to, tokenId, _data),\n      \"ERC721A: transfer to non ERC721Receiver implementer\"\n    );\n  }\n\n  /**\n   * @dev Returns whether `tokenId` exists.\n   *\n   * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.\n   *\n   * Tokens start existing when they are minted (`_mint`),\n   */\n  function _exists(uint256 tokenId) internal view returns (bool) {\n    return tokenId < currentIndex;\n  }\n\n  function _safeMint(address to, uint256 quantity) internal {\n    _safeMint(to, quantity, \"\");\n  }\n\n  /**\n   * @dev Mints `quantity` tokens and transfers them to `to`.\n   *\n   * Requirements:\n   *\n   * - `to` cannot be the zero address.\n   * - `quantity` cannot be larger than the max batch size.\n   *\n   * Emits a {Transfer} event.\n   */\n  function _safeMint(\n    address to,\n    uint256 quantity,\n    bytes memory _data\n  ) internal {\n    uint256 startTokenId = currentIndex;\n    require(to != address(0), \"ERC721A: mint to the zero address\");\n    // We know if the first token in the batch doesn't exist, the other ones don't as well, because of serial ordering.\n    require(!_exists(startTokenId), \"ERC721A: token already minted\");\n    require(quantity <= maxBatchSize, \"ERC721A: quantity to mint too high\");\n\n    _beforeTokenTransfers(address(0), to, startTokenId, quantity);\n\n    AddressData memory addressData = _addressData[to];\n    _addressData[to] = AddressData(\n      addressData.balance + uint128(quantity),\n      addressData.numberMinted + uint128(quantity)\n    );\n    _ownerships[startTokenId] = TokenOwnership(to, uint64(block.timestamp));\n\n    uint256 updatedIndex = startTokenId;\n\n    for (uint256 i = 0; i < quantity; i++) {\n      emit Transfer(address(0), to, updatedIndex);\n      require(\n        _checkOnERC721Received(address(0), to, updatedIndex, _data),\n        \"ERC721A: transfer to non ERC721Receiver implementer\"\n      );\n      updatedIndex++;\n    }\n\n    currentIndex = updatedIndex;\n    _afterTokenTransfers(address(0), to, startTokenId, quantity);\n  }\n\n  /**\n   * @dev Transfers `tokenId` from `from` to `to`.\n   *\n   * Requirements:\n   *\n   * - `to` cannot be the zero address.\n   * - `tokenId` token must be owned by `from`.\n   *\n   * Emits a {Transfer} event.\n   */\n  function _transfer(\n    address from,\n    address to,\n    uint256 tokenId\n  ) private {\n    TokenOwnership memory prevOwnership = ownershipOf(tokenId);\n\n    bool isApprovedOrOwner = (_msgSender() == prevOwnership.addr ||\n      getApproved(tokenId) == _msgSender() ||\n      isApprovedForAll(prevOwnership.addr, _msgSender()));\n\n    require(\n      isApprovedOrOwner,\n      \"ERC721A: transfer caller is not owner nor approved\"\n    );\n\n    require(\n      prevOwnership.addr == from,\n      \"ERC721A: transfer from incorrect owner\"\n    );\n    require(to != address(0), \"ERC721A: transfer to the zero address\");\n\n    _beforeTokenTransfers(from, to, tokenId, 1);\n\n    // Clear approvals from the previous owner\n    _approve(address(0), tokenId, prevOwnership.addr);\n\n    _addressData[from].balance -= 1;\n    _addressData[to].balance += 1;\n    _ownerships[tokenId] = TokenOwnership(to, uint64(block.timestamp));\n\n    // If the ownership slot of tokenId+1 is not explicitly set, that means the transfer initiator owns it.\n    // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.\n    uint256 nextTokenId = tokenId + 1;\n    if (_ownerships[nextTokenId].addr == address(0)) {\n      if (_exists(nextTokenId)) {\n        _ownerships[nextTokenId] = TokenOwnership(\n          prevOwnership.addr,\n          prevOwnership.startTimestamp\n        );\n      }\n    }\n\n    emit Transfer(from, to, tokenId);\n    _afterTokenTransfers(from, to, tokenId, 1);\n  }\n\n  /**\n   * @dev Approve `to` to operate on `tokenId`\n   *\n   * Emits a {Approval} event.\n   */\n  function _approve(\n    address to,\n    uint256 tokenId,\n    address owner\n  ) private {\n    _tokenApprovals[tokenId] = to;\n    emit Approval(owner, to, tokenId);\n  }\n\n  uint256 public nextOwnerToExplicitlySet = 0;\n\n  /**\n   * @dev Explicitly set `owners` to eliminate loops in future calls of ownerOf().\n   */\n  function _setOwnersExplicit(uint256 quantity) internal {\n    uint256 oldNextOwnerToSet = nextOwnerToExplicitlySet;\n    require(quantity > 0, \"quantity must be nonzero\");\n    uint256 endIndex = oldNextOwnerToSet + quantity - 1;\n    if (endIndex > currentIndex - 1) {\n      endIndex = currentIndex - 1;\n    }\n    // We know if the last one in the group exists, all in the group exist, due to serial ordering.\n    require(_exists(endIndex), \"not enough minted yet for this cleanup\");\n    for (uint256 i = oldNextOwnerToSet; i <= endIndex; i++) {\n      if (_ownerships[i].addr == address(0)) {\n        TokenOwnership memory ownership = ownershipOf(i);\n        _ownerships[i] = TokenOwnership(\n          ownership.addr,\n          ownership.startTimestamp\n        );\n      }\n    }\n    nextOwnerToExplicitlySet = endIndex + 1;\n  }\n\n  /**\n   * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.\n   * The call is not executed if the target address is not a contract.\n   *\n   * @param from address representing the previous owner of the given token ID\n   * @param to target address that will receive the tokens\n   * @param tokenId uint256 ID of the token to be transferred\n   * @param _data bytes optional data to send along with the call\n   * @return bool whether the call correctly returned the expected magic value\n   */\n  function _checkOnERC721Received(\n    address from,\n    address to,\n    uint256 tokenId,\n    bytes memory _data\n  ) private returns (bool) {\n    if (to.isContract()) {\n      try\n        IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data)\n      returns (bytes4 retval) {\n        return retval == IERC721Receiver(to).onERC721Received.selector;\n      } catch (bytes memory reason) {\n        if (reason.length == 0) {\n          revert(\"ERC721A: transfer to non ERC721Receiver implementer\");\n        } else {\n          assembly {\n            revert(add(32, reason), mload(reason))\n          }\n        }\n      }\n    } else {\n      return true;\n    }\n  }\n\n  /**\n   * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.\n   *\n   * startTokenId - the first token id to be transferred\n   * quantity - the amount to be transferred\n   *\n   * Calling conditions:\n   *\n   * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be\n   * transferred to `to`.\n   * - When `from` is zero, `tokenId` will be minted for `to`.\n   */\n  function _beforeTokenTransfers(\n    address from,\n    address to,\n    uint256 startTokenId,\n    uint256 quantity\n  ) internal virtual {}\n\n  /**\n   * @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes\n   * minting.\n   *\n   * startTokenId - the first token id to be transferred\n   * quantity - the amount to be transferred\n   *\n   * Calling conditions:\n   *\n   * - when `from` and `to` are both non-zero.\n   * - `from` and `to` are never both zero.\n   */\n  function _afterTokenTransfers(\n    address from,\n    address to,\n    uint256 startTokenId,\n    uint256 quantity\n  ) internal virtual {}\n}\n"
    },
    "@openzeppelin/contracts/utils/introspection/IERC165.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"
    },
    "@openzeppelin/contracts/utils/introspection/ERC165.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC165.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n *\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\n */\nabstract contract ERC165 is IERC165 {\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n        return interfaceId == type(IERC165).interfaceId;\n    }\n}\n"
    },
    "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/cryptography/MerkleProof.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev These functions deal with verification of Merkle Trees proofs.\n *\n * The proofs can be generated using the JavaScript library\n * https://github.com/miguelmota/merkletreejs[merkletreejs].\n * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.\n *\n * See `test/utils/cryptography/MerkleProof.test.js` for some examples.\n */\nlibrary MerkleProof {\n    /**\n     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\n     * defined by `root`. For this, a `proof` must be provided, containing\n     * sibling hashes on the branch from the leaf to the root of the tree. Each\n     * pair of leaves and each pair of pre-images are assumed to be sorted.\n     */\n    function verify(\n        bytes32[] memory proof,\n        bytes32 root,\n        bytes32 leaf\n    ) internal pure returns (bool) {\n        return processProof(proof, leaf) == root;\n    }\n\n    /**\n     * @dev Returns the rebuilt hash obtained by traversing a Merklee tree up\n     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt\n     * hash matches the root of the tree. When processing the proof, the pairs\n     * of leafs & pre-images are assumed to be sorted.\n     *\n     * _Available since v4.4._\n     */\n    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {\n        bytes32 computedHash = leaf;\n        for (uint256 i = 0; i < proof.length; i++) {\n            bytes32 proofElement = proof[i];\n            if (computedHash <= proofElement) {\n                // Hash(current computed hash + current element of the proof)\n                computedHash = keccak256(abi.encodePacked(computedHash, proofElement));\n            } else {\n                // Hash(current element of the proof + current computed hash)\n                computedHash = keccak256(abi.encodePacked(proofElement, computedHash));\n            }\n        }\n        return computedHash;\n    }\n}\n"
    },
    "@openzeppelin/contracts/utils/Strings.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev String operations.\n */\nlibrary Strings {\n    bytes16 private constant _HEX_SYMBOLS = \"0123456789abcdef\";\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n     */\n    function toString(uint256 value) internal pure returns (string memory) {\n        // Inspired by OraclizeAPI's implementation - MIT licence\n        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\n\n        if (value == 0) {\n            return \"0\";\n        }\n        uint256 temp = value;\n        uint256 digits;\n        while (temp != 0) {\n            digits++;\n            temp /= 10;\n        }\n        bytes memory buffer = new bytes(digits);\n        while (value != 0) {\n            digits -= 1;\n            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\n            value /= 10;\n        }\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(uint256 value) internal pure returns (string memory) {\n        if (value == 0) {\n            return \"0x00\";\n        }\n        uint256 temp = value;\n        uint256 length = 0;\n        while (temp != 0) {\n            length++;\n            temp >>= 8;\n        }\n        return toHexString(value, length);\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n     */\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n        bytes memory buffer = new bytes(2 * length + 2);\n        buffer[0] = \"0\";\n        buffer[1] = \"x\";\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\n            buffer[i] = _HEX_SYMBOLS[value & 0xf];\n            value >>= 4;\n        }\n        require(value == 0, \"Strings: hex length insufficient\");\n        return string(buffer);\n    }\n}\n"
    },
    "@openzeppelin/contracts/utils/Context.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n}\n"
    },
    "@openzeppelin/contracts/utils/Address.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Address.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n    /**\n     * @dev Returns true if `account` is a contract.\n     *\n     * [IMPORTANT]\n     * ====\n     * It is unsafe to assume that an address for which this function returns\n     * false is an externally-owned account (EOA) and not a contract.\n     *\n     * Among others, `isContract` will return false for the following\n     * types of addresses:\n     *\n     *  - an externally-owned account\n     *  - a contract in construction\n     *  - an address where a contract will be created\n     *  - an address where a contract lived, but was destroyed\n     * ====\n     */\n    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize, which returns 0 for contracts in\n        // construction, since the code is only stored at the end of the\n        // constructor execution.\n\n        uint256 size;\n        assembly {\n            size := extcodesize(account)\n        }\n        return size > 0;\n    }\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        require(success, \"Address: unable to send value, recipient may have reverted\");\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason, it is bubbled up by this\n     * function (like regular Solidity function calls).\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCall(target, data, \"Address: low-level call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n     * `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        require(address(this).balance >= value, \"Address: insufficient balance for call\");\n        require(isContract(target), \"Address: call to non-contract\");\n\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResult(success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        return functionStaticCall(target, data, \"Address: low-level static call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        require(isContract(target), \"Address: static call to non-contract\");\n\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResult(success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        require(isContract(target), \"Address: delegate call to non-contract\");\n\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResult(success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\n     * revert reason using the provided one.\n     *\n     * _Available since v4.3._\n     */\n    function verifyCallResult(\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal pure returns (bytes memory) {\n        if (success) {\n            return returndata;\n        } else {\n            // Look for revert reason and bubble it up if present\n            if (returndata.length > 0) {\n                // The easiest way to bubble the revert reason is using memory via assembly\n\n                assembly {\n                    let returndata_size := mload(returndata)\n                    revert(add(32, returndata), returndata_size)\n                }\n            } else {\n                revert(errorMessage);\n            }\n        }\n    }\n}\n"
    },
    "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC721.sol\";\n\n/**\n * @title ERC-721 Non-Fungible Token Standard, optional metadata extension\n * @dev See https://eips.ethereum.org/EIPS/eip-721\n */\ninterface IERC721Metadata is IERC721 {\n    /**\n     * @dev Returns the token collection name.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the token collection symbol.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\n     */\n    function tokenURI(uint256 tokenId) external view returns (string memory);\n}\n"
    },
    "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Enumerable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC721.sol\";\n\n/**\n * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension\n * @dev See https://eips.ethereum.org/EIPS/eip-721\n */\ninterface IERC721Enumerable is IERC721 {\n    /**\n     * @dev Returns the total amount of tokens stored by the contract.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.\n     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.\n     */\n    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);\n\n    /**\n     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.\n     * Use along with {totalSupply} to enumerate all tokens.\n     */\n    function tokenByIndex(uint256 index) external view returns (uint256);\n}\n"
    },
    "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721Receiver.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @title ERC721 token receiver interface\n * @dev Interface for any contract that wants to support safeTransfers\n * from ERC721 asset contracts.\n */\ninterface IERC721Receiver {\n    /**\n     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\n     * by `operator` from `from`, this function is called.\n     *\n     * It must return its Solidity selector to confirm the token transfer.\n     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\n     *\n     * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.\n     */\n    function onERC721Received(\n        address operator,\n        address from,\n        uint256 tokenId,\n        bytes calldata data\n    ) external returns (bytes4);\n}\n"
    },
    "@openzeppelin/contracts/token/ERC721/IERC721.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../../utils/introspection/IERC165.sol\";\n\n/**\n * @dev Required interface of an ERC721 compliant contract.\n */\ninterface IERC721 is IERC165 {\n    /**\n     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\n\n    /**\n     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\n     */\n    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\n\n    /**\n     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\n     */\n    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\n\n    /**\n     * @dev Returns the number of tokens in ``owner``'s account.\n     */\n    function balanceOf(address owner) external view returns (uint256 balance);\n\n    /**\n     * @dev Returns the owner of the `tokenId` token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     */\n    function ownerOf(uint256 tokenId) external view returns (address owner);\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\n     * are aware of the ERC721 protocol to prevent tokens from being forever locked.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must exist and be owned by `from`.\n     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function safeTransferFrom(\n        address from,\n        address to,\n        uint256 tokenId\n    ) external;\n\n    /**\n     * @dev Transfers `tokenId` token from `from` to `to`.\n     *\n     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must be owned by `from`.\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(\n        address from,\n        address to,\n        uint256 tokenId\n    ) external;\n\n    /**\n     * @dev Gives permission to `to` to transfer `tokenId` token to another account.\n     * The approval is cleared when the token is transferred.\n     *\n     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\n     *\n     * Requirements:\n     *\n     * - The caller must own the token or be an approved operator.\n     * - `tokenId` must exist.\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address to, uint256 tokenId) external;\n\n    /**\n     * @dev Returns the account approved for `tokenId` token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     */\n    function getApproved(uint256 tokenId) external view returns (address operator);\n\n    /**\n     * @dev Approve or remove `operator` as an operator for the caller.\n     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\n     *\n     * Requirements:\n     *\n     * - The `operator` cannot be the caller.\n     *\n     * Emits an {ApprovalForAll} event.\n     */\n    function setApprovalForAll(address operator, bool _approved) external;\n\n    /**\n     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\n     *\n     * See {setApprovalForAll}\n     */\n    function isApprovedForAll(address owner, address operator) external view returns (bool);\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must exist and be owned by `from`.\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function safeTransferFrom(\n        address from,\n        address to,\n        uint256 tokenId,\n        bytes calldata data\n    ) external;\n}\n"
    },
    "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\nimport \"../../../utils/Address.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n    using Address for address;\n\n    function safeTransfer(\n        IERC20 token,\n        address to,\n        uint256 value\n    ) internal {\n        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\n    }\n\n    function safeTransferFrom(\n        IERC20 token,\n        address from,\n        address to,\n        uint256 value\n    ) internal {\n        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\n    }\n\n    /**\n     * @dev Deprecated. This function has issues similar to the ones found in\n     * {IERC20-approve}, and its usage is discouraged.\n     *\n     * Whenever possible, use {safeIncreaseAllowance} and\n     * {safeDecreaseAllowance} instead.\n     */\n    function safeApprove(\n        IERC20 token,\n        address spender,\n        uint256 value\n    ) internal {\n        // safeApprove should only be called when setting an initial allowance,\n        // or when resetting it to zero. To increase and decrease it, use\n        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\n        require(\n            (value == 0) || (token.allowance(address(this), spender) == 0),\n            \"SafeERC20: approve from non-zero to non-zero allowance\"\n        );\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\n    }\n\n    function safeIncreaseAllowance(\n        IERC20 token,\n        address spender,\n        uint256 value\n    ) internal {\n        uint256 newAllowance = token.allowance(address(this), spender) + value;\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n    }\n\n    function safeDecreaseAllowance(\n        IERC20 token,\n        address spender,\n        uint256 value\n    ) internal {\n        unchecked {\n            uint256 oldAllowance = token.allowance(address(this), spender);\n            require(oldAllowance >= value, \"SafeERC20: decreased allowance below zero\");\n            uint256 newAllowance = oldAllowance - value;\n            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\n     * @param token The token targeted by the call.\n     * @param data The call data (encoded using abi.encode or one of its variants).\n     */\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\n        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\n        // the target address contains contract code and also asserts for success in the low-level call.\n\n        bytes memory returndata = address(token).functionCall(data, \"SafeERC20: low-level call failed\");\n        if (returndata.length > 0) {\n            // Return data is optional\n            require(abi.decode(returndata, (bool)), \"SafeERC20: ERC20 operation did not succeed\");\n        }\n    }\n}\n"
    },
    "@openzeppelin/contracts/token/ERC20/IERC20.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n    /**\n     * @dev Returns the amount of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the amount of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves `amount` tokens from the caller's account to `recipient`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address recipient, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Moves `amount` tokens from `sender` to `recipient` using the\n     * allowance mechanism. `amount` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(\n        address sender,\n        address recipient,\n        uint256 amount\n    ) external returns (bool);\n\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n}\n"
    },
    "@openzeppelin/contracts/security/Pausable.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (security/Pausable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which allows children to implement an emergency stop\n * mechanism that can be triggered by an authorized account.\n *\n * This module is used through inheritance. It will make available the\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\n * the functions of your contract. Note that they will not be pausable by\n * simply including this module, only once the modifiers are put in place.\n */\nabstract contract Pausable is Context {\n    /**\n     * @dev Emitted when the pause is triggered by `account`.\n     */\n    event Paused(address account);\n\n    /**\n     * @dev Emitted when the pause is lifted by `account`.\n     */\n    event Unpaused(address account);\n\n    bool private _paused;\n\n    /**\n     * @dev Initializes the contract in unpaused state.\n     */\n    constructor() {\n        _paused = false;\n    }\n\n    /**\n     * @dev Returns true if the contract is paused, and false otherwise.\n     */\n    function paused() public view virtual returns (bool) {\n        return _paused;\n    }\n\n    /**\n     * @dev Modifier to make a function callable only when the contract is not paused.\n     *\n     * Requirements:\n     *\n     * - The contract must not be paused.\n     */\n    modifier whenNotPaused() {\n        require(!paused(), \"Pausable: paused\");\n        _;\n    }\n\n    /**\n     * @dev Modifier to make a function callable only when the contract is paused.\n     *\n     * Requirements:\n     *\n     * - The contract must be paused.\n     */\n    modifier whenPaused() {\n        require(paused(), \"Pausable: not paused\");\n        _;\n    }\n\n    /**\n     * @dev Triggers stopped state.\n     *\n     * Requirements:\n     *\n     * - The contract must not be paused.\n     */\n    function _pause() internal virtual whenNotPaused {\n        _paused = true;\n        emit Paused(_msgSender());\n    }\n\n    /**\n     * @dev Returns to normal state.\n     *\n     * Requirements:\n     *\n     * - The contract must be paused.\n     */\n    function _unpause() internal virtual whenPaused {\n        _paused = false;\n        emit Unpaused(_msgSender());\n    }\n}\n"
    },
    "@openzeppelin/contracts/finance/PaymentSplitter.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (finance/PaymentSplitter.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../token/ERC20/utils/SafeERC20.sol\";\nimport \"../utils/Address.sol\";\nimport \"../utils/Context.sol\";\n\n/**\n * @title PaymentSplitter\n * @dev This contract allows to split Ether payments among a group of accounts. The sender does not need to be aware\n * that the Ether will be split in this way, since it is handled transparently by the contract.\n *\n * The split can be in equal parts or in any other arbitrary proportion. The way this is specified is by assigning each\n * account to a number of shares. Of all the Ether that this contract receives, each account will then be able to claim\n * an amount proportional to the percentage of total shares they were assigned.\n *\n * `PaymentSplitter` follows a _pull payment_ model. This means that payments are not automatically forwarded to the\n * accounts but kept in this contract, and the actual transfer is triggered as a separate step by calling the {release}\n * function.\n *\n * NOTE: This contract assumes that ERC20 tokens will behave similarly to native tokens (Ether). Rebasing tokens, and\n * tokens that apply fees during transfers, are likely to not be supported as expected. If in doubt, we encourage you\n * to run tests before sending real value to this contract.\n */\ncontract PaymentSplitter is Context {\n    event PayeeAdded(address account, uint256 shares);\n    event PaymentReleased(address to, uint256 amount);\n    event ERC20PaymentReleased(IERC20 indexed token, address to, uint256 amount);\n    event PaymentReceived(address from, uint256 amount);\n\n    uint256 private _totalShares;\n    uint256 private _totalReleased;\n\n    mapping(address => uint256) private _shares;\n    mapping(address => uint256) private _released;\n    address[] private _payees;\n\n    mapping(IERC20 => uint256) private _erc20TotalReleased;\n    mapping(IERC20 => mapping(address => uint256)) private _erc20Released;\n\n    /**\n     * @dev Creates an instance of `PaymentSplitter` where each account in `payees` is assigned the number of shares at\n     * the matching position in the `shares` array.\n     *\n     * All addresses in `payees` must be non-zero. Both arrays must have the same non-zero length, and there must be no\n     * duplicates in `payees`.\n     */\n    constructor(address[] memory payees, uint256[] memory shares_) payable {\n        require(payees.length == shares_.length, \"PaymentSplitter: payees and shares length mismatch\");\n        require(payees.length > 0, \"PaymentSplitter: no payees\");\n\n        for (uint256 i = 0; i < payees.length; i++) {\n            _addPayee(payees[i], shares_[i]);\n        }\n    }\n\n    /**\n     * @dev The Ether received will be logged with {PaymentReceived} events. Note that these events are not fully\n     * reliable: it's possible for a contract to receive Ether without triggering this function. This only affects the\n     * reliability of the events, and not the actual splitting of Ether.\n     *\n     * To learn more about this see the Solidity documentation for\n     * https://solidity.readthedocs.io/en/latest/contracts.html#fallback-function[fallback\n     * functions].\n     */\n    receive() external payable virtual {\n        emit PaymentReceived(_msgSender(), msg.value);\n    }\n\n    /**\n     * @dev Getter for the total shares held by payees.\n     */\n    function totalShares() public view returns (uint256) {\n        return _totalShares;\n    }\n\n    /**\n     * @dev Getter for the total amount of Ether already released.\n     */\n    function totalReleased() public view returns (uint256) {\n        return _totalReleased;\n    }\n\n    /**\n     * @dev Getter for the total amount of `token` already released. `token` should be the address of an IERC20\n     * contract.\n     */\n    function totalReleased(IERC20 token) public view returns (uint256) {\n        return _erc20TotalReleased[token];\n    }\n\n    /**\n     * @dev Getter for the amount of shares held by an account.\n     */\n    function shares(address account) public view returns (uint256) {\n        return _shares[account];\n    }\n\n    /**\n     * @dev Getter for the amount of Ether already released to a payee.\n     */\n    function released(address account) public view returns (uint256) {\n        return _released[account];\n    }\n\n    /**\n     * @dev Getter for the amount of `token` tokens already released to a payee. `token` should be the address of an\n     * IERC20 contract.\n     */\n    function released(IERC20 token, address account) public view returns (uint256) {\n        return _erc20Released[token][account];\n    }\n\n    /**\n     * @dev Getter for the address of the payee number `index`.\n     */\n    function payee(uint256 index) public view returns (address) {\n        return _payees[index];\n    }\n\n    /**\n     * @dev Triggers a transfer to `account` of the amount of Ether they are owed, according to their percentage of the\n     * total shares and their previous withdrawals.\n     */\n    function release(address payable account) public virtual {\n        require(_shares[account] > 0, \"PaymentSplitter: account has no shares\");\n\n        uint256 totalReceived = address(this).balance + totalReleased();\n        uint256 payment = _pendingPayment(account, totalReceived, released(account));\n\n        require(payment != 0, \"PaymentSplitter: account is not due payment\");\n\n        _released[account] += payment;\n        _totalReleased += payment;\n\n        Address.sendValue(account, payment);\n        emit PaymentReleased(account, payment);\n    }\n\n    /**\n     * @dev Triggers a transfer to `account` of the amount of `token` tokens they are owed, according to their\n     * percentage of the total shares and their previous withdrawals. `token` must be the address of an IERC20\n     * contract.\n     */\n    function release(IERC20 token, address account) public virtual {\n        require(_shares[account] > 0, \"PaymentSplitter: account has no shares\");\n\n        uint256 totalReceived = token.balanceOf(address(this)) + totalReleased(token);\n        uint256 payment = _pendingPayment(account, totalReceived, released(token, account));\n\n        require(payment != 0, \"PaymentSplitter: account is not due payment\");\n\n        _erc20Released[token][account] += payment;\n        _erc20TotalReleased[token] += payment;\n\n        SafeERC20.safeTransfer(token, account, payment);\n        emit ERC20PaymentReleased(token, account, payment);\n    }\n\n    /**\n     * @dev internal logic for computing the pending payment of an `account` given the token historical balances and\n     * already released amounts.\n     */\n    function _pendingPayment(\n        address account,\n        uint256 totalReceived,\n        uint256 alreadyReleased\n    ) private view returns (uint256) {\n        return (totalReceived * _shares[account]) / _totalShares - alreadyReleased;\n    }\n\n    /**\n     * @dev Add a new payee to the contract.\n     * @param account The address of the payee to add.\n     * @param shares_ The number of shares owned by the payee.\n     */\n    function _addPayee(address account, uint256 shares_) private {\n        require(account != address(0), \"PaymentSplitter: account is the zero address\");\n        require(shares_ > 0, \"PaymentSplitter: shares are 0\");\n        require(_shares[account] == 0, \"PaymentSplitter: account already has shares\");\n\n        _payees.push(account);\n        _shares[account] = shares_;\n        _totalShares = _totalShares + shares_;\n        emit PayeeAdded(account, shares_);\n    }\n}\n"
    },
    "@openzeppelin/contracts/access/Ownable.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n    address private _owner;\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the deployer as the initial owner.\n     */\n    constructor() {\n        _transferOwnership(_msgSender());\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n        _;\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions anymore. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby removing any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n"
    }
  },
  "settings": {
    "remappings": [],
    "optimizer": {
      "enabled": true,
      "runs": 200
    },
    "evmVersion": "byzantium",
    "libraries": {},
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    }
  }
}}

Contract sourced from Etherscan. Solidity version v0.8.9+commit.e5eed63a.

Panoramix decompilation

# Palkeoramix decompiler. 

def storage:
  owner is address at storage 0
  stor1 is uint256 at storage 1
  stor2 is array of struct at storage 2
  stor3 is array of struct at storage 3
  stor4 is mapping of struct at storage 4
  balanceOf is mapping of struct at storage 5
  approved is mapping of address at storage 6
  stor7 is mapping of uint8 at storage 7
  nextOwnerToExplicitlySet is uint256 at storage 8
  stor9 is uint32 at storage 9 offset 160
  stor9 is address at storage 9
  paused is uint8 at storage 10
  totalShares is uint256 at storage 11
  totalReleased is uint256 at storage 12
  shares is mapping of uint256 at storage 13
  released is mapping of uint256 at storage 14
  payee is array of address at storage 15
  totalReleased is mapping of uint256 at storage 16
  released is mapping of uint256 at storage 17
  stor18 is array of struct at storage 18
  _merkleRoot is uint256 at storage 19
  _price is uint256 at storage 20
  _presalePrice is uint256 at storage 21
  MAX_TOTAL_MINT is uint256 at storage 22
  _maxPerAddress is uint256 at storage 23
  _presaleMaxPerAddress is uint256 at storage 24
  _publicSaleTime is uint256 at storage 25
  _preSaleTime is uint256 at storage 26
  _maxTxPerAddress is uint256 at storage 27
  stor28 is mapping of uint256 at storage 28

def getApproved(uint256 tokenId): # not payable
  require calldata.size - 4 >=′ 32
  if stor1 <= tokenId:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'ERC721A: approved query for nonexistent token'
  return approved[tokenId]

def _maxSupply(): # not payable
  return MAX_TOTAL_MINT

def _price(): # not payable
  return _price

def _merkleRoot(): # not payable
  return _merkleRoot

def totalShares(): # not payable
  return totalShares

def released(address token, address account): # not payable
  require calldata.size - 4 >=′ 64
  require token == token
  require account == account
  return released[address(token)][address(account)]

def paused(): # not payable
  return bool(paused)

def _presalePrice(): # not payable
  return _presalePrice

def _maxTxPerAddress(): # not payable
  return _maxTxPerAddress

def balanceOf(address account): # not payable
  require calldata.size - 4 >=′ 32
  require account == account
  if not account:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'ERC721A: balance query for the zero address'
  return balanceOf[address(account)].field_0

def payee(uint256 index): # not payable
  require calldata.size - 4 >=′ 32
  if index >= payee.length:
      revert with 0, 50
  return payee[index]

def owner(): # not payable
  return owner

def _presaleMaxPerAddress(): # not payable
  return _presaleMaxPerAddress

def released(address account): # not payable
  require calldata.size - 4 >=′ 32
  require account == account
  return released[address(account)]

def _publicSaleTime(): # not payable
  return _publicSaleTime

def shares(address account): # not payable
  require calldata.size - 4 >=′ 32
  require account == account
  return shares[address(account)]

def MAX_TOTAL_MINT(): # not payable
  return MAX_TOTAL_MINT

def nextOwnerToExplicitlySet(): # not payable
  return nextOwnerToExplicitlySet

def totalReleased(address token): # not payable
  require calldata.size - 4 >=′ 32
  require token == token
  return totalReleased[address(token)]

def _maxPerAddress(): # not payable
  return _maxPerAddress

def totalReleased(): # not payable
  return totalReleased

def isApprovedForAll(address owner, address operator): # not payable
  require calldata.size - 4 >=′ 64
  require owner == owner
  require operator == operator
  return bool(stor7[address(owner)][address(operator)])

def _preSaleTime(): # not payable
  return _preSaleTime

#
#  Regular functions
#

def totalSupply(): # not payable
  if stor1 < 1:
      revert with 0, 17
  return (stor1 - 1)

def isPublicSaleActive(): # not payable
  if not _publicSaleTime:
      return not _publicSaleTime
  return (_publicSaleTime < block.timestamp)

def setMerkleRoot(bytes32 _merkleRoot): # not payable
  require calldata.size - 4 >=′ 32
  if owner != caller:
      revert with 0, 'Ownable: caller is not the owner'
  _merkleRoot = _merkleRoot

def pause(): # not payable
  if owner != caller:
      revert with 0, 'Ownable: caller is not the owner'
  if paused:
      revert with 0, 'Pausable: paused'
  paused = 1
  log Paused(address account=caller)

def unpause(): # not payable
  if owner != caller:
      revert with 0, 'Ownable: caller is not the owner'
  if not paused:
      revert with 0, 'Pausable: not paused'
  paused = 0
  log Unpaused(address account=caller)

def PRICE(): # not payable
  if _preSaleTime:
      if _preSaleTime >= block.timestamp:
          return _price
      if block.timestamp >= _publicSaleTime:
          return _price
  return _presalePrice

def renounceOwnership(): # not payable
  if owner != caller:
      revert with 0, 'Ownable: caller is not the owner'
  owner = 0
  log OwnershipTransferred(
        address previousOwner=owner,
        address newOwner=0)

def isPreSaleActive(): # not payable
  if not _preSaleTime:
      return not _preSaleTime
  if _preSaleTime >= block.timestamp:
      return (_preSaleTime < block.timestamp)
  return (block.timestamp < _publicSaleTime)

def MAX_TOTAL_MINT_PER_ADDRESS(): # not payable
  if _preSaleTime:
      if _preSaleTime >= block.timestamp:
          return _maxPerAddress
      if block.timestamp >= _publicSaleTime:
          return _maxPerAddress
  return _presaleMaxPerAddress

def tokenByIndex(uint256 index): # not payable
  require calldata.size - 4 >=′ 32
  if stor1 < 1:
      revert with 0, 17
  if index >= stor1 - 1:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'ERC721A: global index out of bounds'
  return index

def royaltyInfo(uint256 _tokenId, uint256 _salePrice): # not payable
  require calldata.size - 4 >=′ 64
  if _salePrice and stor9.field_160 % unknown01000000() > -1 / _salePrice:
      revert with 0, 17
  return address(stor9.field_0), _salePrice * stor9.field_160 % unknown01000000() / 10000

def updateRoyalties(address recipient, uint256 bps): # not payable
  require calldata.size - 4 >=′ 64
  require recipient == recipient
  if owner != caller:
      revert with 0, 'Ownable: caller is not the owner'
  if bps > 10000:
      revert with 0, 'ERC2981Royalties: Too high'
  address(stor9.field_0) = recipient
  stor9.field_160 % unknown01000000() = bps % unknown01000000()

def transferOwnership(address newOwner): # not payable
  require calldata.size - 4 >=′ 32
  require newOwner == newOwner
  if owner != caller:
      revert with 0, 'Ownable: caller is not the owner'
  if not newOwner:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Ownable: new owner is the zero address'
  owner = newOwner
  log OwnershipTransferred(
        address previousOwner=owner,
        address newOwner=newOwner)

def setApprovalForAll(address operator, bool approved): # not payable
  require calldata.size - 4 >=′ 64
  require operator == operator
  require approved == approved
  if caller == operator:
      revert with 0, 'ERC721A: approve to caller'
  stor7[caller][address(operator)] = uint8(approved)
  log ApprovalForAll(
        address owner=approved,
        address operator=caller,
        bool approved=operator)

def supportsInterface(bytes4 interfaceId): # not payable
  require calldata.size - 4 >=′ 32
  require interfaceId == Mask(32, 224, interfaceId)
  if '*U Z' == Mask(32, 224, interfaceId):
      return True
  if 0x80ac58cd00000000000000000000000000000000000000000000000000000000 == Mask(32, 224, interfaceId):
      return True
  if 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == Mask(32, 224, interfaceId):
      return True
  if 0x780e9d6300000000000000000000000000000000000000000000000000000000 == Mask(32, 224, interfaceId):
      return True
  return (Mask(32, 224, interfaceId) == 0x1ffc9a700000000000000000000000000000000000000000000000000000000)

def setSaleInformation(uint256 publicSaleTime, uint256 preSaleTime, uint256 maxPerAddress, uint256 presaleMaxPerAddress, uint256 price, uint256 presalePrice, bytes32 merkleRoot, uint256 maxTxPerAddress): # not payable
  require calldata.size - 4 >=′ 256
  if owner != caller:
      revert with 0, 'Ownable: caller is not the owner'
  _publicSaleTime = publicSaleTime
  _preSaleTime = preSaleTime
  _maxPerAddress = maxPerAddress
  _presaleMaxPerAddress = presaleMaxPerAddress
  _price = price
  _presalePrice = presalePrice
  _merkleRoot = merkleRoot
  _maxTxPerAddress = maxTxPerAddress

def ownerOf(uint256 tokenId): # not payable
  require calldata.size - 4 >=′ 32
  mem[64] = 160
  if stor1 <= tokenId:
      revert with 0, 'ERC721A: owner query for nonexistent token'
  if tokenId < 2500:
      idx = tokenId
      while idx >= 0:
          mem[0] = idx
          mem[32] = 4
          _20 = mem[64]
          mem[64] = mem[64] + 64
          mem[_20] = stor4[idx].field_0
          mem[_20 + 32] = stor4[idx].field_160
          if stor4[idx].field_0:
              return stor4[idx].field_0
          if not idx:
              revert with 0, 17
          idx = idx - 1
          continue 
  else:
      if 1 > !(tokenId - 2500):
          revert with 0, 17
      idx = tokenId
      while idx >= tokenId - 2499:
          mem[0] = idx
          mem[32] = 4
          _23 = mem[64]
          mem[64] = mem[64] + 64
          mem[_23] = stor4[idx].field_0
          mem[_23 + 32] = stor4[idx].field_160
          if stor4[idx].field_0:
              return stor4[idx].field_0
          if not idx:
              revert with 0, 17
          idx = idx - 1
          continue 
  revert with 0, 'ERC721A: unable to determine the owner of token'

def setBaseUri(string _uri): # not payable
  require calldata.size - 4 >=′ 32
  require _uri <= LOCK8605463013()
  require calldata.size >′ _uri + 35
  if _uri.length > LOCK8605463013():
      revert with 0, 65
  if ceil32(ceil32(_uri.length)) + 97 < 96 or ceil32(ceil32(_uri.length)) + 97 > LOCK8605463013():
      revert with 0, 65
  require _uri + _uri.length + 36 <= calldata.size
  if owner != caller:
      revert with 0, 'Ownable: caller is not the owner'
  if bool(stor18.length):
      if bool(stor18.length) == stor18.length.field_1 < 32:
          revert with 0, 34
      if _uri.length:
          stor18[].field_0 = Array(len=_uri.length, data=_uri[all])
      else:
          stor18.length = 0
          idx = 0
          while stor18.length.field_1 + 31 / 32 > idx:
              stor18[idx].field_0 = 0
              idx = idx + 1
              continue 
  else:
      if bool(stor18.length) == stor18.length.field_1 < 32:
          revert with 0, 34
      if _uri.length:
          stor18[].field_0 = Array(len=_uri.length, data=_uri[all])
      else:
          stor18.length = 0
          idx = 0
          while stor18.length.field_1 + 31 / 32 > idx:
              stor18[idx].field_0 = 0
              idx = idx + 1
              continue 

def onEarlyPurchaseList(address addr, bytes32[] merkleProof): # not payable
  require calldata.size - 4 >=′ 64
  require addr == addr
  require merkleProof <= LOCK8605463013()
  require merkleProof + 35 <′ calldata.size
  require merkleProof.length <= LOCK8605463013()
  require merkleProof + (32 * merkleProof.length) + 36 <= calldata.size
  mem[128] = address(addr)
  mem[96] = 20
  mem[64] = (32 * merkleProof.length) + 180
  mem[148] = merkleProof.length
  mem[180 len 32 * merkleProof.length] = call.data[merkleProof + 36 len 32 * merkleProof.length]
  mem[(32 * merkleProof.length) + 180] = 0
  idx = 0
  s = 0
  while idx < merkleProof.length:
      if idx >= mem[148]:
          revert with 0, 50
      _21 = mem[(32 * idx) + 180]
      if s + sha3(mem[128 len 20]) > mem[(32 * idx) + 180]:
          mem[mem[64] + 32] = mem[(32 * idx) + 180]
          mem[mem[64] + 64] = s + sha3(mem[128 len 20])
          _23 = mem[64]
          mem[mem[64]] = 64
          mem[64] = mem[64] + 96
          if idx == -1:
              revert with 0, 17
          idx = idx + 1
          s = sha3(mem[_23 + 32 len mem[_23]])
          continue 
      mem[mem[64] + 32] = s + sha3(mem[128 len 20])
      mem[mem[64] + 64] = _21
      _27 = mem[64]
      mem[mem[64]] = 64
      mem[64] = mem[64] + 96
      if idx == -1:
          revert with 0, 17
      idx = idx + 1
      s = sha3(mem[_27 + 32 len mem[_27]])
      continue 
  return (s == _merkleRoot)

def tokenOfOwnerByIndex(address owner, uint256 index) payable: 
  mem[64] = 96
  require not call.value
  require calldata.size - 4 >=′ 64
  require owner == owner
  if not owner:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'ERC721A: balance query for the zero address'
  if index >= balanceOf[address(owner)].field_0:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'ERC721A: owner index out of bounds'
  if stor1 < 1:
      revert with 0, 17
  idx = 0
  s = 0
  t = 0
  while idx < stor1 - 1:
      mem[0] = idx
      mem[32] = 4
      _17 = mem[64]
      mem[64] = mem[64] + 64
      mem[_17] = stor4[idx].field_0
      mem[_17 + 32] = stor4[idx].field_160
      if not stor4[idx].field_0:
          if address(s) != owner:
              if idx == -1:
                  revert with 0, 17
              idx = idx + 1
              s = s
              t = t
              continue 
          if t == index:
              return idx
          if t == -1:
              revert with 0, 17
          if idx == -1:
              revert with 0, 17
          idx = idx + 1
          s = s
          t = t + 1
          continue 
      if stor4[idx].field_0 != owner:
          if idx == -1:
              revert with 0, 17
          idx = idx + 1
          s = stor4[idx].field_0
          t = t
          continue 
      if t == index:
          return idx
      if t == -1:
          revert with 0, 17
      if idx == -1:
          revert with 0, 17
      idx = idx + 1
      s = stor4[idx].field_0
      t = t + 1
      continue 
  revert with 0, 'ERC721A: unable to get token of owner by index'

def approve(address spender, uint256 amount): # not payable
  require calldata.size - 4 >=′ 64
  require spender == spender
  mem[64] = 160
  if stor1 <= amount:
      revert with 0, 'ERC721A: owner query for nonexistent token'
  if amount < 2500:
      idx = amount
      while idx >= 0:
          mem[0] = idx
          mem[32] = 4
          _36 = mem[64]
          mem[64] = mem[64] + 64
          mem[_36] = stor4[idx].field_0
          mem[_36 + 32] = stor4[idx].field_160
          if not stor4[idx].field_0:
              if not idx:
                  revert with 0, 17
              idx = idx - 1
              continue 
          if spender == stor4[idx].field_0:
              revert with 0, 'ERC721A: approval to current owner'
          if stor4[idx].field_0 != caller:
              if not stor7[stor4[idx].field_0][caller]:
                  revert with 0, 'ERC721A: approve caller is not owner nor approved for all'
          approved[amount] = spender
          log Approval(
                address owner=stor4[idx].field_0,
                address spender=spender,
                uint256 value=amount)
          stop
  else:
      if 1 > !(amount - 2500):
          revert with 0, 17
      idx = amount
      while idx >= amount - 2499:
          mem[0] = idx
          mem[32] = 4
          _39 = mem[64]
          mem[64] = mem[64] + 64
          mem[_39] = stor4[idx].field_0
          mem[_39 + 32] = stor4[idx].field_160
          if not stor4[idx].field_0:
              if not idx:
                  revert with 0, 17
              idx = idx - 1
              continue 
          if spender == stor4[idx].field_0:
              revert with 0, 'ERC721A: approval to current owner'
          if stor4[idx].field_0 != caller:
              if not stor7[stor4[idx].field_0][caller]:
                  revert with 0, 'ERC721A: approve caller is not owner nor approved for all'
          approved[amount] = spender
          log Approval(
                address owner=stor4[idx].field_0,
                address spender=spender,
                uint256 value=amount)
          stop
  revert with 0, 'ERC721A: unable to determine the owner of token'

def tokenURI(uint256 tokenId): # not payable
  require calldata.size - 4 >=′ 32
  if stor1 <= tokenId:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'ERC721Metadata: URI query for nonexistent token'
  idx = 41
  s = this.address
  while idx > 1:
      if s % 16 >= 16:
          revert with 0, 50
      if idx >= 42:
          revert with 0, 50
      mem[idx + 128 len 8] = Mask(8, -(0, 0) + 256, 0) << (0, 0) - 256
      if not idx:
          revert with 0, 17
      idx = idx - 1
      s = s / 16
      continue 
  if this.address + 10080:
      revert with 0, 'Strings: hex length insufficient'
  if bool(stor18.length):
      if bool(stor18.length) == stor18.length.field_1 < 32:
          revert with 0, 34
      if bool(stor18.length):
          if bool(stor18.length) != 1:
              return ''
          idx = 0
          s = 0
          while idx < stor18.length.field_1:
              mem[idx + 224] = stor18[s].field_0
              idx = idx + 32
              s = s + 1
              continue 
          if stor18.length.field_1 + 43 > 0:
              if not tokenId:
      else:
          if stor18.length.field_1 + 43 <= 0:
              return ''
          if tokenId:
              s = 0
              idx = tokenId
              while idx:
                  if s == -1:
                      revert with 0, 17
                  s = s + 1
                  idx = idx / 10
                  continue 
              if s > LOCK8605463013():
                  revert with 0, 65
              if tokenId:
                  if s < 1:
                      revert with 0, 17
                  if 48 > !(tokenId % 10):
                      revert with 0, 17
  else:
      if bool(stor18.length) == stor18.length.field_1 < 32:
          revert with 0, 34
      if bool(stor18.length):
          if bool(stor18.length) != 1:
              return ''
          idx = 0
          s = 0
          while idx < stor18.length.field_1:
              mem[idx + 224] = stor18[s].field_0
              idx = idx + 32
              s = s + 1
              continue 
          if stor18.length.field_1 + 43 > 0:
              if not tokenId:
      else:
          if stor18.length.field_1 + 43 <= 0:
              return ''
          if tokenId:
              s = 0
              idx = tokenId
              while idx:
                  if s == -1:
                      revert with 0, 17
                  s = s + 1
                  idx = idx / 10
                  continue 
              if s > LOCK8605463013():
                  revert with 0, 65
              if tokenId:
                  if s < 1:
                      revert with 0, 17
                  if 48 > !(tokenId % 10):
                      revert with 0, 17
  ...  # Decompilation aborted, sorry: ("decompilation didn't finish",)

def release(address account): # not payable
  require calldata.size - 4 >=′ 32
  require account == account
  if not shares[address(account)]:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'PaymentSplitter: account has no shares'
  if eth.balance(this.address) > !totalReleased:
      revert with 0, 17
  if eth.balance(this.address) + totalReleased and shares[address(account)] > -1 / eth.balance(this.address) + totalReleased:
      revert with 0, 17
  if not totalShares:
      revert with 0, 18
  if (eth.balance(this.address) * shares[address(account)]) + (totalReleased * shares[address(account)]) / totalShares < released[address(account)]:
      revert with 0, 17
  if not ((eth.balance(this.address) * shares[address(account)]) + (totalReleased * shares[address(account)]) / totalShares) - released[address(account)]:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'PaymentSplitter: account is not due payment'
  if released[address(account)] > !(((eth.balance(this.address) * shares[address(account)]) + (totalReleased * shares[address(account)]) / totalShares) - released[address(account)]):
      revert with 0, 17
  released[address(account)] = (eth.balance(this.address) * shares[address(account)]) + (totalReleased * shares[address(account)]) / totalShares
  if totalReleased > !(((eth.balance(this.address) * shares[address(account)]) + (totalReleased * shares[address(account)]) / totalShares) - released[address(account)]):
      revert with 0, 17
  totalReleased = totalReleased + ((eth.balance(this.address) * shares[address(account)]) + (totalReleased * shares[address(account)]) / totalShares) - released[address(account)]
  if ((eth.balance(this.address) * shares[address(account)]) + (totalReleased * shares[address(account)]) / totalShares) - released[address(account)] > eth.balance(this.address):
      revert with 0, 'Address: insufficient balance'
  call account with:
     value ((eth.balance(this.address) * shares[address(account)]) + (totalReleased * shares[address(account)]) / totalShares) - released[address(account)] wei
       gas gas_remaining wei
  if not return_data.size:
      if not ext_call.success:
          revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 
                      'Address: unable to send value, recipient may have reverted'
  else:
      if not ext_call.success:
          revert with 0, 'Address: unable to send value, recipient may have reverted'
  ('bool', 'ext_call.success')
  log PaymentReleased(
        address to=address(account),
        uint256 amount=((eth.balance(this.address) * shares[address(account)]) + (totalReleased * shares[address(account)]) / totalShares) - released[address(account)])

def name(): # not payable
  if bool(stor2.length):
      if bool(stor2.length) == stor2.length.field_1 < 32:
          revert with 0, 34
      if bool(stor2.length):
          if bool(stor2.length) == stor2.length.field_1 < 32:
              revert with 0, 34
          if stor2.length.field_1:
              if 31 < stor2.length.field_1:
                  mem[128] = uint256(stor2.field_0)
                  idx = 128
                  s = 0
                  while stor2.length.field_1 + 96 > idx:
                      mem[idx + 32] = stor2[s].field_256
                      idx = idx + 32
                      s = s + 1
                      continue 
                  return Array(len=2 * Mask(256, -1, stor2.length.field_1), data=mem[128 len ceil32(stor2.length.field_1)])
              mem[128] = 256 * stor2.length.field_8
      else:
          if bool(stor2.length) == stor2.length.field_1 < 32:
              revert with 0, 34
          if stor2.length.field_1:
              if 31 < stor2.length.field_1:
                  mem[128] = uint256(stor2.field_0)
                  idx = 128
                  s = 0
                  while stor2.length.field_1 + 96 > idx:
                      mem[idx + 32] = stor2[s].field_256
                      idx = idx + 32
                      s = s + 1
                      continue 
                  return Array(len=2 * Mask(256, -1, stor2.length.field_1), data=mem[128 len ceil32(stor2.length.field_1)])
              mem[128] = 256 * stor2.length.field_8
      mem[ceil32(stor2.length.field_1) + 192 len ceil32(stor2.length.field_1)] = mem[128 len ceil32(stor2.length.field_1)]
      if ceil32(stor2.length.field_1) > stor2.length.field_1:
          mem[stor2.length.field_1 + ceil32(stor2.length.field_1) + 192] = 0
      return Array(len=2 * Mask(256, -1, stor2.length.field_1), data=mem[128 len ceil32(stor2.length.field_1)], mem[(2 * ceil32(stor2.length.field_1)) + 192 len 2 * ceil32(stor2.length.field_1)]), 
  if bool(stor2.length) == stor2.length.field_1 < 32:
      revert with 0, 34
  if bool(stor2.length):
      if bool(stor2.length) == stor2.length.field_1 < 32:
          revert with 0, 34
      if stor2.length.field_1:
          if 31 < stor2.length.field_1:
              mem[128] = uint256(stor2.field_0)
              idx = 128
              s = 0
              while stor2.length.field_1 + 96 > idx:
                  mem[idx + 32] = stor2[s].field_256
                  idx = idx + 32
                  s = s + 1
                  continue 
              return Array(len=stor2.length % 128, data=mem[128 len ceil32(stor2.length.field_1)])
          mem[128] = 256 * stor2.length.field_8
  else:
      if bool(stor2.length) == stor2.length.field_1 < 32:
          revert with 0, 34
      if stor2.length.field_1:
          if 31 < stor2.length.field_1:
              mem[128] = uint256(stor2.field_0)
              idx = 128
              s = 0
              while stor2.length.field_1 + 96 > idx:
                  mem[idx + 32] = stor2[s].field_256
                  idx = idx + 32
                  s = s + 1
                  continue 
              return Array(len=stor2.length % 128, data=mem[128 len ceil32(stor2.length.field_1)])
          mem[128] = 256 * stor2.length.field_8
  mem[ceil32(stor2.length.field_1) + 192 len ceil32(stor2.length.field_1)] = mem[128 len ceil32(stor2.length.field_1)]
  if ceil32(stor2.length.field_1) > stor2.length.field_1:
      mem[stor2.length.field_1 + ceil32(stor2.length.field_1) + 192] = 0
  return Array(len=stor2.length % 128, data=mem[128 len ceil32(stor2.length.field_1)], mem[(2 * ceil32(stor2.length.field_1)) + 192 len 2 * ceil32(stor2.length.field_1)]), 

def symbol(): # not payable
  if bool(stor3.length):
      if bool(stor3.length) == stor3.length.field_1 < 32:
          revert with 0, 34
      if bool(stor3.length):
          if bool(stor3.length) == stor3.length.field_1 < 32:
              revert with 0, 34
          if stor3.length.field_1:
              if 31 < stor3.length.field_1:
                  mem[128] = uint256(stor3.field_0)
                  idx = 128
                  s = 0
                  while stor3.length.field_1 + 96 > idx:
                      mem[idx + 32] = stor3[s].field_256
                      idx = idx + 32
                      s = s + 1
                      continue 
                  return Array(len=2 * Mask(256, -1, stor3.length.field_1), data=mem[128 len ceil32(stor3.length.field_1)])
              mem[128] = 256 * stor3.length.field_8
      else:
          if bool(stor3.length) == stor3.length.field_1 < 32:
              revert with 0, 34
          if stor3.length.field_1:
              if 31 < stor3.length.field_1:
                  mem[128] = uint256(stor3.field_0)
                  idx = 128
                  s = 0
                  while stor3.length.field_1 + 96 > idx:
                      mem[idx + 32] = stor3[s].field_256
                      idx = idx + 32
                      s = s + 1
                      continue 
                  return Array(len=2 * Mask(256, -1, stor3.length.field_1), data=mem[128 len ceil32(stor3.length.field_1)])
              mem[128] = 256 * stor3.length.field_8
      mem[ceil32(stor3.length.field_1) + 192 len ceil32(stor3.length.field_1)] = mem[128 len ceil32(stor3.length.field_1)]
      if ceil32(stor3.length.field_1) > stor3.length.field_1:
          mem[stor3.length.field_1 + ceil32(stor3.length.field_1) + 192] = 0
      return Array(len=2 * Mask(256, -1, stor3.length.field_1), data=mem[128 len ceil32(stor3.length.field_1)], mem[(2 * ceil32(stor3.length.field_1)) + 192 len 2 * ceil32(stor3.length.field_1)]), 
  if bool(stor3.length) == stor3.length.field_1 < 32:
      revert with 0, 34
  if bool(stor3.length):
      if bool(stor3.length) == stor3.length.field_1 < 32:
          revert with 0, 34
      if stor3.length.field_1:
          if 31 < stor3.length.field_1:
              mem[128] = uint256(stor3.field_0)
              idx = 128
              s = 0
              while stor3.length.field_1 + 96 > idx:
                  mem[idx + 32] = stor3[s].field_256
                  idx = idx + 32
                  s = s + 1
                  continue 
              return Array(len=stor3.length % 128, data=mem[128 len ceil32(stor3.length.field_1)])
          mem[128] = 256 * stor3.length.field_8
  else:
      if bool(stor3.length) == stor3.length.field_1 < 32:
          revert with 0, 34
      if stor3.length.field_1:
          if 31 < stor3.length.field_1:
              mem[128] = uint256(stor3.field_0)
              idx = 128
              s = 0
              while stor3.length.field_1 + 96 > idx:
                  mem[idx + 32] = stor3[s].field_256
                  idx = idx + 32
                  s = s + 1
                  continue 
              return Array(len=stor3.length % 128, data=mem[128 len ceil32(stor3.length.field_1)])
          mem[128] = 256 * stor3.length.field_8
  mem[ceil32(stor3.length.field_1) + 192 len ceil32(stor3.length.field_1)] = mem[128 len ceil32(stor3.length.field_1)]
  if ceil32(stor3.length.field_1) > stor3.length.field_1:
      mem[stor3.length.field_1 + ceil32(stor3.length.field_1) + 192] = 0
  return Array(len=stor3.length % 128, data=mem[128 len ceil32(stor3.length.field_1)], mem[(2 * ceil32(stor3.length.field_1)) + 192 len 2 * ceil32(stor3.length.field_1)]), 

def _baseTokenURI(): # not payable
  if bool(stor18.length):
      if bool(stor18.length) == stor18.length.field_1 < 32:
          revert with 0, 34
      if bool(stor18.length):
          if bool(stor18.length) == stor18.length.field_1 < 32:
              revert with 0, 34
          if stor18.length.field_1:
              if 31 < stor18.length.field_1:
                  mem[128] = uint256(stor18.field_0)
                  idx = 128
                  s = 0
                  while stor18.length.field_1 + 96 > idx:
                      mem[idx + 32] = stor18[s].field_256
                      idx = idx + 32
                      s = s + 1
                      continue 
                  return Array(len=2 * Mask(256, -1, stor18.length.field_1), data=mem[128 len ceil32(stor18.length.field_1)])
              mem[128] = 256 * stor18.length.field_8
      else:
          if bool(stor18.length) == stor18.length.field_1 < 32:
              revert with 0, 34
          if stor18.length.field_1:
              if 31 < stor18.length.field_1:
                  mem[128] = uint256(stor18.field_0)
                  idx = 128
                  s = 0
                  while stor18.length.field_1 + 96 > idx:
                      mem[idx + 32] = stor18[s].field_256
                      idx = idx + 32
                      s = s + 1
                      continue 
                  return Array(len=2 * Mask(256, -1, stor18.length.field_1), data=mem[128 len ceil32(stor18.length.field_1)])
              mem[128] = 256 * stor18.length.field_8
      mem[ceil32(stor18.length.field_1) + 192 len ceil32(stor18.length.field_1)] = mem[128 len ceil32(stor18.length.field_1)]
      if ceil32(stor18.length.field_1) > stor18.length.field_1:
          mem[stor18.length.field_1 + ceil32(stor18.length.field_1) + 192] = 0
      return Array(len=2 * Mask(256, -1, stor18.length.field_1), data=mem[128 len ceil32(stor18.length.field_1)], mem[(2 * ceil32(stor18.length.field_1)) + 192 len 2 * ceil32(stor18.length.field_1)]), 
  if bool(stor18.length) == stor18.length.field_1 < 32:
      revert with 0, 34
  if bool(stor18.length):
      if bool(stor18.length) == stor18.length.field_1 < 32:
          revert with 0, 34
      if stor18.length.field_1:
          if 31 < stor18.length.field_1:
              mem[128] = uint256(stor18.field_0)
              idx = 128
              s = 0
              while stor18.length.field_1 + 96 > idx:
                  mem[idx + 32] = stor18[s].field_256
                  idx = idx + 32
                  s = s + 1
                  continue 
              return Array(len=stor18.length % 128, data=mem[128 len ceil32(stor18.length.field_1)])
          mem[128] = 256 * stor18.length.field_8
  else:
      if bool(stor18.length) == stor18.length.field_1 < 32:
          revert with 0, 34
      if stor18.length.field_1:
          if 31 < stor18.length.field_1:
              mem[128] = uint256(stor18.field_0)
              idx = 128
              s = 0
              while stor18.length.field_1 + 96 > idx:
                  mem[idx + 32] = stor18[s].field_256
                  idx = idx + 32
                  s = s + 1
                  continue 
              return Array(len=stor18.length % 128, data=mem[128 len ceil32(stor18.length.field_1)])
          mem[128] = 256 * stor18.length.field_8
  mem[ceil32(stor18.length.field_1) + 192 len ceil32(stor18.length.field_1)] = mem[128 len ceil32(stor18.length.field_1)]
  if ceil32(stor18.length.field_1) > stor18.length.field_1:
      mem[stor18.length.field_1 + ceil32(stor18.length.field_1) + 192] = 0
  return Array(len=stor18.length % 128, data=mem[128 len ceil32(stor18.length.field_1)], mem[(2 * ceil32(stor18.length.field_1)) + 192 len 2 * ceil32(stor18.length.field_1)]), 

def mint(address _to, uint256 _amount) payable: 
  require calldata.size - 4 >=′ 64
  require _to == _to
  if owner != caller:
      revert with 0, 'Ownable: caller is not the owner'
  if stor1 < 1:
      revert with 0, 17
  if stor1 - 1 > !_amount:
      revert with 0, 17
  if stor1 + _amount - 1 > MAX_TOTAL_MINT:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'BASE_COLLECTION/EXCEEDS_MAX_SUPPLY'
  mem[96] = 0
  if not _to:
      revert with 0, 'ERC721A: mint to the zero address'
  if stor1 > stor1:
      revert with 0, 'ERC721A: token already minted'
  if _amount > 2500:
      revert with 0, 'ERC721A: quantity to mint too high'
  mem[128] = balanceOf[address(_to)].field_0
  mem[160] = balanceOf[address(_to)].field_128
  if balanceOf[address(_to)].field_0 > -uint128(_amount) + LOCK8605463013():
      revert with 0, 17
  mem[192] = uint128(uint128(_amount) + balanceOf[address(_to)].field_0)
  if balanceOf[address(_to)].field_128 > -uint128(_amount) + LOCK8605463013():
      revert with 0, 17
  mem[224] = uint128(uint128(_amount) + balanceOf[address(_to)].field_128)
  balanceOf[address(_to)].field_0 = uint128(uint128(_amount) + balanceOf[address(_to)].field_0)
  balanceOf[address(_to)].field_128 = uint128(uint128(_amount) + balanceOf[address(_to)].field_128)
  mem[64] = 320
  mem[256] = _to
  mem[288] = uint64(block.timestamp)
  mem[0] = stor1
  mem[32] = 4
  stor4[stor1].field_0 = _to
  stor4[stor1].field_160 = uint64(block.timestamp)
  idx = 0
  s = stor1
  while idx < _amount:
      log Transfer(
            address from=0,
            address to=_to,
            uint256 value=s)
      if ext_code.size(_to):
          mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
          mem[mem[64] + 4] = caller
          mem[mem[64] + 36] = 0
          mem[mem[64] + 68] = s
          mem[mem[64] + 100] = 128
          mem[mem[64] + 132] = mem[96]
          t = 0
          while t < mem[96]:
              mem[t + mem[64] + 164] = mem[t + 128]
              t = t + 32
              continue 
          if ceil32(mem[96]) <= mem[96]:
              require ext_code.size(_to)
              call _to.onERC721Received(address , address , uint256 , bytes ) with:
                   gas gas_remaining wei
                  args caller, 0, s, 128, mem[96], mem[mem[64] + 164 len ceil32(mem[96])]
              mem[mem[64]] = ext_call.return_data[0]
              if not ext_call.success:
                  if not return_data.size:
                      if not mem[96]:
                          revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                      revert with memory
                        from 128
                         len mem[96]
                  if not return_data.size:
                      revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                  revert with ext_call.return_data[0 len return_data.size]
              _91 = mem[64]
              mem[64] = mem[64] + ceil32(return_data.size)
              require return_data.size >=′ 32
              require mem[_91] == Mask(32, 224, mem[_91])
              if Mask(32, 224, mem[_91]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
                  revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
          else:
              mem[mem[96] + mem[64] + 164] = 0
              require ext_code.size(_to)
              call _to.onERC721Received(address , address , uint256 , bytes ) with:
                   gas gas_remaining wei
                  args caller, 0, s, 128, mem[96], mem[mem[64] + 164 len ceil32(mem[96])]
              mem[mem[64]] = ext_call.return_data[0]
              if not ext_call.success:
                  if not return_data.size:
                      if not mem[96]:
                          revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                      revert with memory
                        from 128
                         len mem[96]
                  if not return_data.size:
                      revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                  revert with ext_call.return_data[0 len return_data.size]
              _92 = mem[64]
              mem[64] = mem[64] + ceil32(return_data.size)
              require return_data.size >=′ 32
              require mem[_92] == Mask(32, 224, mem[_92])
              if Mask(32, 224, mem[_92]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
                  revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
      if s == -1:
          revert with 0, 17
      if idx == -1:
          revert with 0, 17
      idx = idx + 1
      s = s + 1
      continue 
  stor1 = s

def transferFrom(address sender, address recipient, uint256 amount): # not payable
  require calldata.size - 4 >=′ 96
  require sender == sender
  require recipient == recipient
  mem[64] = 160
  if stor1 <= amount:
      revert with 0, 'ERC721A: owner query for nonexistent token'
  if amount < 2500:
      idx = amount
      while idx >= 0:
          mem[0] = idx
          mem[32] = 4
          _194 = mem[64]
          mem[64] = mem[64] + 64
          mem[_194] = stor4[idx].field_0
          mem[_194 + 32] = stor4[idx].field_160
          if not stor4[idx].field_0:
              if not idx:
                  revert with 0, 17
              idx = idx - 1
              continue 
          if stor4[idx].field_0 != caller:
              if stor1 <= amount:
                  revert with 0, 'ERC721A: approved query for nonexistent token'
              if approved[amount] != caller:
                  if not stor7[stor4[idx].field_0][caller]:
                      revert with 0, 'ERC721A: transfer caller is not owner nor approved'
          if stor4[idx].field_0 != sender:
              revert with 0, 'ERC721A: transfer from incorrect owner'
          if not recipient:
              revert with 0, 'ERC721A: transfer to the zero address'
          approved[amount] = 0
          log Approval(
                address owner=stor4[idx].field_0,
                address spender=0,
                uint256 value=amount)
          if balanceOf[address(sender)].field_0 < 1:
              revert with 0, 17
          balanceOf[address(sender)].field_0 = uint128(balanceOf[address(sender)].field_0 - 1)
          if balanceOf[address(recipient)].field_0 > LOCK8605463013():
              revert with 0, 17
          balanceOf[address(recipient)].field_0 = uint128(balanceOf[address(recipient)].field_0 + 1)
          stor4[amount].field_0 = recipient
          stor4[amount].field_160 = uint64(block.timestamp)
          if 1 > !amount:
              revert with 0, 17
          if not stor4[amount + 1].field_0:
              if stor1 > amount + 1:
                  stor4[amount + 1].field_0 = stor4[idx].field_0
                  stor4[amount + 1].field_160 = stor4[idx].field_160
          log Transfer(
                address from=sender,
                address to=recipient,
                uint256 value=amount)
          stop
  else:
      if 1 > !(amount - 2500):
          revert with 0, 17
      idx = amount
      while idx >= amount - 2499:
          mem[0] = idx
          mem[32] = 4
          _197 = mem[64]
          mem[64] = mem[64] + 64
          mem[_197] = stor4[idx].field_0
          mem[_197 + 32] = stor4[idx].field_160
          if not stor4[idx].field_0:
              if not idx:
                  revert with 0, 17
              idx = idx - 1
              continue 
          if stor4[idx].field_0 != caller:
              if stor1 <= amount:
                  revert with 0, 'ERC721A: approved query for nonexistent token'
              if approved[amount] != caller:
                  if not stor7[stor4[idx].field_0][caller]:
                      revert with 0, 'ERC721A: transfer caller is not owner nor approved'
          if stor4[idx].field_0 != sender:
              revert with 0, 'ERC721A: transfer from incorrect owner'
          if not recipient:
              revert with 0, 'ERC721A: transfer to the zero address'
          approved[amount] = 0
          log Approval(
                address owner=stor4[idx].field_0,
                address spender=0,
                uint256 value=amount)
          if balanceOf[address(sender)].field_0 < 1:
              revert with 0, 17
          balanceOf[address(sender)].field_0 = uint128(balanceOf[address(sender)].field_0 - 1)
          if balanceOf[address(recipient)].field_0 > LOCK8605463013():
              revert with 0, 17
          balanceOf[address(recipient)].field_0 = uint128(balanceOf[address(recipient)].field_0 + 1)
          stor4[amount].field_0 = recipient
          stor4[amount].field_160 = uint64(block.timestamp)
          if 1 > !amount:
              revert with 0, 17
          if not stor4[amount + 1].field_0:
              if stor1 > amount + 1:
                  stor4[amount + 1].field_0 = stor4[idx].field_0
                  stor4[amount + 1].field_160 = stor4[idx].field_160
          log Transfer(
                address from=sender,
                address to=recipient,
                uint256 value=amount)
          stop
  revert with 0, 'ERC721A: unable to determine the owner of token'

def release(address token, address account): # not payable
  require calldata.size - 4 >=′ 64
  require token == token
  require account == account
  if not shares[address(account)]:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'PaymentSplitter: account has no shares'
  mem[100] = this.address
  require ext_code.size(token)
  static call token.balanceOf(address account) with:
          gas gas_remaining wei
         args this.address
  mem[96] = ext_call.return_data[0]
  if not ext_call.success:
      revert with ext_call.return_data[0 len return_data.size]
  require return_data.size >=′ 32
  if ext_call.return_data[0] > !totalReleased[address(token)]:
      revert with 0, 17
  if ext_call.return_data[0] + totalReleased[address(token)] and shares[address(account)] > -1 / ext_call.return_data[0] + totalReleased[address(token)]:
      revert with 0, 17
  if not totalShares:
      revert with 0, 18
  if (ext_call.return_data[0] * shares[address(account)]) + (totalReleased[address(token)] * shares[address(account)]) / totalShares < released[address(token)][address(account)]:
      revert with 0, 17
  if not ((ext_call.return_data[0] * shares[address(account)]) + (totalReleased[address(token)] * shares[address(account)]) / totalShares) - released[address(token)][address(account)]:
      revert with 0, 'PaymentSplitter: account is not due payment'
  if released[address(token)][address(account)] > !(((ext_call.return_data[0] * shares[address(account)]) + (totalReleased[address(token)] * shares[address(account)]) / totalShares) - released[address(token)][address(account)]):
      revert with 0, 17
  released[address(token)][address(account)] = (ext_call.return_data[0] * shares[address(account)]) + (totalReleased[address(token)] * shares[address(account)]) / totalShares
  if totalReleased[address(token)] > !(((ext_call.return_data[0] * shares[address(account)]) + (totalReleased[address(token)] * shares[address(account)]) / totalShares) - released[address(token)][address(account)]):
      revert with 0, 17
  totalReleased[address(token)] = totalReleased[address(token)] + ((ext_call.return_data[0] * shares[address(account)]) + (totalReleased[address(token)] * shares[address(account)]) / totalShares) - released[address(token)][address(account)]
  mem[ceil32(return_data.size) + 132] = account
  mem[ceil32(return_data.size) + 164] = ((ext_call.return_data[0] * shares[address(account)]) + (totalReleased[address(token)] * shares[address(account)]) / totalShares) - released[address(token)][address(account)]
  mem[ceil32(return_data.size) + 96] = 68
  mem[ceil32(return_data.size) + 132 len 28] = address(account) << 64
  mem[ceil32(return_data.size) + 128 len 4] = transfer(address recipient, uint256 amount)
  mem[ceil32(return_data.size) + 196] = 32
  mem[ceil32(return_data.size) + 228] = 'SafeERC20: low-level call failed'
  if not ext_code.size(token):
      revert with 0, 'Address: call to non-contract'
  mem[ceil32(return_data.size) + 260 len 96] = transfer(address recipient, uint256 amount), address(account) << 64, 0, ((ext_call.return_data[0] * shares[address(account)]) + (totalReleased[address(token)] * shares[address(account)]) / totalShares) - released[address(token)][address(account)], 0
  mem[ceil32(return_data.size) + 328] = 0
  call token with:
     funct Mask(32, 224, transfer(address recipient, uint256 amount), address(account) << 64, 0, ((ext_call.return_data[0] * shares[address(account)]) + (totalReleased[address(token)] * shares[address(account)]) / totalShares) - released[address(token)][address(account)], 0) >> 224
       gas gas_remaining wei
      args (Mask(512, -288, transfer(address recipient, uint256 amount), address(account) << 64, 0, ((ext_call.return_data[0] * shares[address(account)]) + (totalReleased[address(token)] * shares[address(account)]) / totalShares) - released[address(token)][address(account)], 0) << 288)
  if not return_data.size:
      if not ext_call.success:
          if ext_call.return_data[0]:
              revert with memory
                from 128
                 len ext_call.return_data[0]
          revert with 0, 'SafeERC20: low-level call failed'
      if ext_call.return_data[0]:
          require ext_call.return_data[0] >=′ 32
          require uint32(this.address), mem[132 len 28] == bool(uint32(this.address), mem[132 len 28])
          if not uint32(this.address), mem[132 len 28]:
              revert with 0, 'SafeERC20: ERC20 operation did not succeed'
  else:
      mem[ceil32(return_data.size) + 292 len return_data.size] = ext_call.return_data[0 len return_data.size]
      if not ext_call.success:
          if return_data.size:
              revert with ext_call.return_data[0 len return_data.size]
          revert with 0, 'SafeERC20: low-level call failed'
      if return_data.size:
          require return_data.size >=′ 32
          require mem[ceil32(return_data.size) + 292] == bool(mem[ceil32(return_data.size) + 292])
          if not mem[ceil32(return_data.size) + 292]:
              revert with 0, 'SafeERC20: ERC20 operation did not succeed'
  log ERC20PaymentReleased(
        address token=address(account),
        address to=((ext_call.return_data[0] * shares[address(account)]) + (totalReleased[address(token)] * shares[address(account)]) / totalShares) - released[address(token)][address(account)],
        uint256 amount=token)

def _fallback(?) payable: # default function
  if calldata.size < 4:
      require not calldata.size
      log PaymentReceived(
            address from=caller,
            uint256 amount=call.value)
      stop
  if setSaleInformation(uint256 publicSaleTime, uint256 preSaleTime, uint256 maxPerAddress, uint256 presaleMaxPerAddress, uint256 price, uint256 presalePrice, bytes32 merkleRoot, uint256 maxTxPerAddress) > uint32(call.func_hash):
      if unpause() > uint32(call.func_hash):
          if _maxSupply() <= uint32(call.func_hash):
              if royaltyInfo(uint256 _tokenId, uint256 _salePrice) <= uint32(call.func_hash):
                  if royaltyInfo(uint256 _tokenId, uint256 _salePrice) == uint32(call.func_hash):
                      require not call.value
                      require calldata.size - 4 >=′ 64
                      if _param2 and stor9.field_160 % unknown01000000() > -1 / _param2:
                          revert with 0, 17
                      return address(stor9.field_0), _param2 * stor9.field_160 % unknown01000000() / 10000
                  if uint32(call.func_hash) != tokenOfOwnerByIndex(address owner, uint256 index):
                      if _merkleRoot() == uint32(call.func_hash):
                          require not call.value
                          return _merkleRoot
                      require totalShares() == uint32(call.func_hash)
                      require not call.value
                      return totalShares
                  require not call.value
                  require calldata.size - 4 >=′ 64
                  require _param1 == address(_param1)
                  if not address(_param1):
                      revert with 0, 'ERC721A: balance query for the zero address'
                  if _param2 >= balanceOf[address(_param1)].field_0:
                      revert with 0, 'ERC721A: owner index out of bounds'
                  if stor1 < 1:
                      revert with 0, 17
              else:
                  if _maxSupply() == uint32(call.func_hash):
                      require not call.value
                      return MAX_TOTAL_MINT
                  if _price() == uint32(call.func_hash):
                      require not call.value
                      return _price
                  require transferFrom(address sender, address recipient, uint256 amount) == uint32(call.func_hash)
                  require not call.value
                  require calldata.size - 4 >=′ 96
                  require _param1 == address(_param1)
                  require _param2 == address(_param2)
                  if stor1 <= _param3:
                      revert with 0, 'ERC721A: owner query for nonexistent token'
                  if _param3 >= 2500:
                      if 1 > !(_param3 - 2500):
                          revert with 0, 17
              ...  # Decompilation aborted, sorry: ("decompilation didn't finish",)
          if approve(address spender, uint256 amount) > uint32(call.func_hash):
              if supportsInterface(bytes4 interfaceId) == uint32(call.func_hash):
                  require not call.value
                  require calldata.size - 4 >=′ 32
                  require _param1 == Mask(32, 224, _param1)
                  if '*U Z' == Mask(32, 224, _param1):
                      return True
                  if 0x80ac58cd00000000000000000000000000000000000000000000000000000000 == Mask(32, 224, _param1):
                      return True
                  if 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == Mask(32, 224, _param1):
                      return True
                  if 0x780e9d6300000000000000000000000000000000000000000000000000000000 == Mask(32, 224, _param1):
                      return True
                  return (Mask(32, 224, _param1) == 0x1ffc9a700000000000000000000000000000000000000000000000000000000)
              if uint32(call.func_hash) != name():
                  require getApproved(uint256 tokenId) == uint32(call.func_hash)
                  require not call.value
                  require calldata.size - 4 >=′ 32
                  if stor1 <= _param1:
                      revert with 0, 'ERC721A: approved query for nonexistent token'
                  return approved[_param1]
              require not call.value
              if bool(stor2.length):
                  if bool(stor2.length) == stor2.length.field_1 < 32:
                      revert with 0, 34
              else:
                  if bool(stor2.length) == stor2.length.field_1 < 32:
                      revert with 0, 34
              if bool(stor2.length):
                  if bool(stor2.length) == stor2.length.field_1 < 32:
                      revert with 0, 34
                  if stor2.length.field_1:
              else:
                  if bool(stor2.length) == stor2.length.field_1 < 32:
                      revert with 0, 34
                  if stor2.length.field_1:
              ...  # Decompilation aborted, sorry: ("decompilation didn't finish",)
          if approve(address spender, uint256 amount) == uint32(call.func_hash):
              require not call.value
              require calldata.size - 4 >=′ 64
              require _param1 == address(_param1)
              if stor1 <= _param2:
                  revert with 0, 'ERC721A: owner query for nonexistent token'
              if _param2 >= 2500:
                  if 1 > !(_param2 - 2500):
                      revert with 0, 17
              ...  # Decompilation aborted, sorry: ("decompilation didn't finish",)
          if totalSupply() == uint32(call.func_hash):
              require not call.value
              if stor1 < 1:
                  revert with 0, 17
              return (stor1 - 1)
          if uint32(call.func_hash) != release(address account):
              require isPublicSaleActive() == uint32(call.func_hash)
              require not call.value
              if not _publicSaleTime:
                  return not _publicSaleTime
              return (_publicSaleTime < block.timestamp)
          require not call.value
          require calldata.size - 4 >=′ 32
          require _param1 == address(_param1)
          if not shares[address(_param1)]:
              revert with 0, 'PaymentSplitter: account has no shares'
          if eth.balance(this.address) > !totalReleased:
              revert with 0, 17
          if eth.balance(this.address) + totalReleased and shares[address(_param1)] > -1 / eth.balance(this.address) + totalReleased:
              revert with 0, 17
          if not totalShares:
              revert with 0, 18
          if (eth.balance(this.address) * shares[address(_param1)]) + (totalReleased * shares[address(_param1)]) / totalShares < released[address(_param1)]:
              revert with 0, 17
          if not ((eth.balance(this.address) * shares[address(_param1)]) + (totalReleased * shares[address(_param1)]) / totalShares) - released[address(_param1)]:
              revert with 0, 'PaymentSplitter: account is not due payment'
          if released[address(_param1)] > !(((eth.balance(this.address) * shares[address(_param1)]) + (totalReleased * shares[address(_param1)]) / totalShares) - released[address(_param1)]):
              revert with 0, 17
          released[address(_param1)] = (eth.balance(this.address) * shares[address(_param1)]) + (totalReleased * shares[address(_param1)]) / totalShares
          if totalReleased > !(((eth.balance(this.address) * shares[address(_param1)]) + (totalReleased * shares[address(_param1)]) / totalShares) - released[address(_param1)]):
              revert with 0, 17
          totalReleased = totalReleased + ((eth.balance(this.address) * shares[address(_param1)]) + (totalReleased * shares[address(_param1)]) / totalShares) - released[address(_param1)]
          if ((eth.balance(this.address) * shares[address(_param1)]) + (totalReleased * shares[address(_param1)]) / totalShares) - released[address(_param1)] > eth.balance(this.address):
              revert with 0, 'Address: insufficient balance'
          call address(_param1) with:
             value ((eth.balance(this.address) * shares[address(_param1)]) + (totalReleased * shares[address(_param1)]) / totalShares) - released[address(_param1)] wei
               gas gas_remaining wei
          if not ext_call.success:
              revert with 0, 'Address: unable to send value, recipient may have reverted'
          log PaymentReleased(
                address to=address(_param1),
                uint256 amount=((eth.balance(this.address) * shares[address(_param1)]) + (totalReleased * shares[address(_param1)]) / totalShares) - released[address(_param1)])
          stop
      if _presalePrice() <= uint32(call.func_hash):
          if _maxTxPerAddress() > uint32(call.func_hash):
              if _presalePrice() == uint32(call.func_hash):
                  require not call.value
                  return _presalePrice
              if ownerOf(uint256 tokenId) == uint32(call.func_hash):
                  require not call.value
                  require calldata.size - 4 >=′ 32
                  if stor1 <= _param1:
                      revert with 0, 'ERC721A: owner query for nonexistent token'
                  if _param1 >= 2500:
                      if 1 > !(_param1 - 2500):
                          revert with 0, 17
                  ...  # Decompilation aborted, sorry: ("decompilation didn't finish",)
              require MAX_TOTAL_MINT_PER_ADDRESS() == uint32(call.func_hash)
              require not call.value
              if _preSaleTime:
                  if _preSaleTime >= block.timestamp:
                      return _maxPerAddress
                  if block.timestamp >= _publicSaleTime:
                      return _maxPerAddress
              return _presaleMaxPerAddress
          if _maxTxPerAddress() == uint32(call.func_hash):
              require not call.value
              return _maxTxPerAddress
          if uint32(call.func_hash) != updateRoyalties(address recipient, uint256 bps):
              if balanceOf(address account) == uint32(call.func_hash):
                  require not call.value
                  require calldata.size - 4 >=′ 32
                  require _param1 == address(_param1)
                  if not address(_param1):
                      revert with 0, 'ERC721A: balance query for the zero address'
                  return balanceOf[address(_param1)].field_0
              require renounceOwnership() == uint32(call.func_hash)
              require not call.value
              if owner != caller:
                  revert with 0, 'Ownable: caller is not the owner'
              owner = 0
              log OwnershipTransferred(
                    address previousOwner=owner,
                    address newOwner=0)
          else:
              require not call.value
              require calldata.size - 4 >=′ 64
              require _param1 == address(_param1)
              if owner != caller:
                  revert with 0, 'Ownable: caller is not the owner'
              if _param2 > 10000:
                  revert with 0, 'ERC2981Royalties: Too high'
              address(stor9.field_0) = address(_param1)
              stor9.field_160 % unknown01000000() = _param2 % unknown01000000()
          stop
      if safeTransferFrom(address from, address to, uint256 tokenId) > uint32(call.func_hash):
          if unpause() == uint32(call.func_hash):
              require not call.value
              if owner != caller:
                  revert with 0, 'Ownable: caller is not the owner'
              if not paused:
                  revert with 0, 'Pausable: not paused'
              paused = 0
              log Unpaused(address account=caller)
              stop
          if released(address token, address account) == uint32(call.func_hash):
              require not call.value
              require calldata.size - 4 >=′ 64
              require _param1 == address(_param1)
              require _param2 == address(_param2)
              return released[address(_param1)][address(_param2)]
          require mint(address _to, uint256 _amount) == uint32(call.func_hash)
          require calldata.size - 4 >=′ 64
          require _param1 == address(_param1)
          if owner != caller:
              revert with 0, 'Ownable: caller is not the owner'
          if stor1 < 1:
              revert with 0, 17
          if stor1 - 1 > !_param2:
              revert with 0, 17
          if stor1 + _param2 - 1 > MAX_TOTAL_MINT:
              revert with 0, 'BASE_COLLECTION/EXCEEDS_MAX_SUPPLY'
          if not address(_param1):
              revert with 0, 'ERC721A: mint to the zero address'
          if stor1 > stor1:
              revert with 0, 'ERC721A: token already minted'
          if _param2 > 2500:
              revert with 0, 'ERC721A: quantity to mint too high'
          if balanceOf[address(_param1)].field_0 > -uint128(_param2) + LOCK8605463013():
              revert with 0, 17
          if balanceOf[address(_param1)].field_128 > -uint128(_param2) + LOCK8605463013():
              revert with 0, 17
          balanceOf[address(_param1)].field_0 = uint128(uint128(_param2) + balanceOf[address(_param1)].field_0)
          balanceOf[address(_param1)].field_128 = uint128(uint128(_param2) + balanceOf[address(_param1)].field_128)
          stor4[stor1].field_0 = address(_param1)
          stor4[stor1].field_160 = uint64(block.timestamp)
      else:
          if safeTransferFrom(address from, address to, uint256 tokenId) == uint32(call.func_hash):
              require not call.value
              require calldata.size - 4 >=′ 96
              require _param1 == address(_param1)
              require _param2 == address(_param2)
              if stor1 <= _param3:
                  revert with 0, 'ERC721A: owner query for nonexistent token'
              if _param3 >= 2500:
                  if 1 > !(_param3 - 2500):
                      revert with 0, 17
          else:
              if uint32(call.func_hash) != release(address token, address account):
                  if uint32(call.func_hash) != tokenByIndex(uint256 index):
                      require paused() == uint32(call.func_hash)
                      require not call.value
                      return bool(paused)
                  require not call.value
                  require calldata.size - 4 >=′ 32
                  if stor1 < 1:
                      revert with 0, 17
                  if _param1 >= stor1 - 1:
                      revert with 0, 'ERC721A: global index out of bounds'
                  return _param1
              require not call.value
              require calldata.size - 4 >=′ 64
              require _param1 == address(_param1)
              require _param2 == address(_param2)
              if not shares[address(_param2)]:
                  revert with 0, 'PaymentSplitter: account has no shares'
              require ext_code.size(address(_param1))
              static call address(_param1).balanceOf(address account) with:
                      gas gas_remaining wei
                     args this.address
              if not ext_call.success:
                  revert with ext_call.return_data[0 len return_data.size]
              require return_data.size >=′ 32
              if ext_call.return_data[0] > !totalReleased[address(_param1)]:
                  revert with 0, 17
              if ext_call.return_data[0] + totalReleased[address(_param1)] and shares[address(_param2)] > -1 / ext_call.return_data[0] + totalReleased[address(_param1)]:
                  revert with 0, 17
              if not totalShares:
                  revert with 0, 18
              if (ext_call.return_data[0] * shares[address(_param2)]) + (totalReleased[address(_param1)] * shares[address(_param2)]) / totalShares < released[address(_param1)][address(_param2)]:
                  revert with 0, 17
              if not ((ext_call.return_data[0] * shares[address(_param2)]) + (totalReleased[address(_param1)] * shares[address(_param2)]) / totalShares) - released[address(_param1)][address(_param2)]:
                  revert with 0, 'PaymentSplitter: account is not due payment'
              if released[address(_param1)][address(_param2)] > !(((ext_call.return_data[0] * shares[address(_param2)]) + (totalReleased[address(_param1)] * shares[address(_param2)]) / totalShares) - released[address(_param1)][address(_param2)]):
                  revert with 0, 17
              released[address(_param1)][address(_param2)] = (ext_call.return_data[0] * shares[address(_param2)]) + (totalReleased[address(_param1)] * shares[address(_param2)]) / totalShares
              if totalReleased[address(_param1)] > !(((ext_call.return_data[0] * shares[address(_param2)]) + (totalReleased[address(_param1)] * shares[address(_param2)]) / totalShares) - released[address(_param1)][address(_param2)]):
                  revert with 0, 17
              totalReleased[address(_param1)] = totalReleased[address(_param1)] + ((ext_call.return_data[0] * shares[address(_param2)]) + (totalReleased[address(_param1)] * shares[address(_param2)]) / totalShares) - released[address(_param1)][address(_param2)]
              if not ext_code.size(address(_param1)):
                  revert with 0, 'Address: call to non-contract'
  else:
      if safeTransferFrom(address from, address to, uint256 tokenId, bytes _data) > uint32(call.func_hash):
          if _presaleMaxPerAddress() > uint32(call.func_hash):
              if pause() <= uint32(call.func_hash):
                  if pause() == uint32(call.func_hash):
                      require not call.value
                      if owner != caller:
                          revert with 0, 'Ownable: caller is not the owner'
                      if paused:
                          revert with 0, 'Pausable: paused'
                      paused = 1
                      log Paused(address account=caller)
                      stop
                  if payee(uint256 index) == uint32(call.func_hash):
                      require not call.value
                      require calldata.size - 4 >=′ 32
                      if _param1 >= payee.length:
                          revert with 0, 50
                      return payee[_param1]
                  if uint32(call.func_hash) != PRICE():
                      require owner() == uint32(call.func_hash)
                      require not call.value
                      return owner
                  require not call.value
                  if _preSaleTime:
                      if _preSaleTime >= block.timestamp:
                          return _price
                      if block.timestamp >= _publicSaleTime:
                          return _price
                  return _presalePrice
              if uint32(call.func_hash) != setSaleInformation(uint256 publicSaleTime, uint256 preSaleTime, uint256 maxPerAddress, uint256 presaleMaxPerAddress, uint256 price, uint256 presalePrice, bytes32 merkleRoot, uint256 maxTxPerAddress):
                  if uint32(call.func_hash) != onEarlyPurchaseList(address addr, bytes32[] merkleProof):
                      require setMerkleRoot(bytes32 _merkleRoot) == uint32(call.func_hash)
                      require not call.value
                      require calldata.size - 4 >=′ 32
                      if owner != caller:
                          revert with 0, 'Ownable: caller is not the owner'
                      _merkleRoot = _param1
                      stop
                  require not call.value
                  require calldata.size - 4 >=′ 64
                  require _param1 == address(_param1)
                  require _param2 <= LOCK8605463013()
                  require _param2 + 35 <′ calldata.size
                  require _param2.length <= LOCK8605463013()
                  require _param2 + (32 * _param2.length) + 36 <= calldata.size
                  ...  # Decompilation aborted, sorry: ("decompilation didn't finish",)
              require not call.value
              require calldata.size - 4 >=′ 256
              if owner != caller:
                  revert with 0, 'Ownable: caller is not the owner'
              _publicSaleTime = _param1
              _preSaleTime = _param2
              _maxPerAddress = _param3
              _presaleMaxPerAddress = _param4
              _price = _param5
              _presalePrice = _param6
              _merkleRoot = _param7
              _maxTxPerAddress = _param8
              stop
          if isPreSaleActive() > uint32(call.func_hash):
              if _presaleMaxPerAddress() == uint32(call.func_hash):
                  require not call.value
                  return _presaleMaxPerAddress
              if uint32(call.func_hash) != symbol():
                  require released(address account) == uint32(call.func_hash)
                  require not call.value
                  require calldata.size - 4 >=′ 32
                  require _param1 == address(_param1)
                  return released[address(_param1)]
              require not call.value
              if bool(stor3.length):
                  if bool(stor3.length) == stor3.length.field_1 < 32:
                      revert with 0, 34
              else:
                  if bool(stor3.length) == stor3.length.field_1 < 32:
                      revert with 0, 34
              if bool(stor3.length):
                  if bool(stor3.length) == stor3.length.field_1 < 32:
                      revert with 0, 34
                  if stor3.length.field_1:
              else:
                  if bool(stor3.length) == stor3.length.field_1 < 32:
                      revert with 0, 34
                  if stor3.length.field_1:
          else:
              if isPreSaleActive() == uint32(call.func_hash):
                  require not call.value
                  if not _preSaleTime:
                      return not _preSaleTime
                  if _preSaleTime >= block.timestamp:
                      return (_preSaleTime < block.timestamp)
                  return (block.timestamp < _publicSaleTime)
              if uint32(call.func_hash) != setBaseUri(string _uri):
                  if uint32(call.func_hash) != setApprovalForAll(address operator, bool approved):
                      require _publicSaleTime() == uint32(call.func_hash)
                      require not call.value
                      return _publicSaleTime
                  require not call.value
                  require calldata.size - 4 >=′ 64
                  require _param1 == address(_param1)
                  require _param2 == bool(_param2)
                  if caller == address(_param1):
                      revert with 0, 'ERC721A: approve to caller'
                  stor7[caller][address(_param1)] = uint8(bool(_param2))
                  log ApprovalForAll(
                        address owner=bool(_param2),
                        address operator=caller,
                        bool approved=address(_param1))
                  stop
              require not call.value
              require calldata.size - 4 >=′ 32
              require _param1 <= LOCK8605463013()
              require calldata.size >′ _param1 + 35
              if _param1.length > LOCK8605463013():
                  revert with 0, 65
              if ceil32(ceil32(_param1.length)) + 129 < 128 or ceil32(ceil32(_param1.length)) + 129 > LOCK8605463013():
                  revert with 0, 65
              require _param1 + _param1.length + 36 <= calldata.size
              if owner != caller:
                  revert with 0, 'Ownable: caller is not the owner'
              if bool(stor18.length):
                  if bool(stor18.length) == stor18.length.field_1 < 32:
                      revert with 0, 34
              else:
                  if bool(stor18.length) == stor18.length.field_1 < 32:
                      revert with 0, 34
              if _param1.length:
                  stor18.length = (2 * _param1.length) + 1
              else:
                  stor18.length = 0
      else:
          if earlyPurchase(uint256 count, bytes32[] merkleProof) > uint32(call.func_hash):
              if MAX_TOTAL_MINT() <= uint32(call.func_hash):
                  if MAX_TOTAL_MINT() == uint32(call.func_hash):
                      require not call.value
                      return MAX_TOTAL_MINT
                  if uint32(call.func_hash) != _baseTokenURI():
                      if nextOwnerToExplicitlySet() == uint32(call.func_hash):
                          require not call.value
                          return nextOwnerToExplicitlySet
                      require totalReleased(address token) == uint32(call.func_hash)
                      require not call.value
                      require calldata.size - 4 >=′ 32
                      require _param1 == address(_param1)
                      return totalReleased[address(_param1)]
                  require not call.value
                  if bool(stor18.length):
                      if bool(stor18.length) == stor18.length.field_1 < 32:
                          revert with 0, 34
                  else:
                      if bool(stor18.length) == stor18.length.field_1 < 32:
                          revert with 0, 34
                  if bool(stor18.length):
                      if bool(stor18.length) == stor18.length.field_1 < 32:
                          revert with 0, 34
                      if stor18.length.field_1:
                  else:
                      if bool(stor18.length) == stor18.length.field_1 < 32:
                          revert with 0, 34
                      if stor18.length.field_1:
              else:
                  if uint32(call.func_hash) != safeTransferFrom(address from, address to, uint256 tokenId, bytes _data):
                      if tokenURI(uint256 tokenId) == uint32(call.func_hash):
                          require not call.value
                          require calldata.size - 4 >=′ 32
                          if stor1 <= _param1:
                              revert with 0, 'ERC721Metadata: URI query for nonexistent token'
                          ...  # Decompilation aborted, sorry: ("decompilation didn't finish",)
                      require shares(address account) == uint32(call.func_hash)
                      require not call.value
                      require calldata.size - 4 >=′ 32
                      require _param1 == address(_param1)
                      return shares[address(_param1)]
                  require not call.value
                  require calldata.size - 4 >=′ 128
                  require _param1 == address(_param1)
                  require _param2 == address(_param2)
                  require _param4 <= LOCK8605463013()
                  require calldata.size >′ _param4 + 35
                  if _param4.length > LOCK8605463013():
                      revert with 0, 65
                  if ceil32(ceil32(_param4.length)) + 129 < 128 or ceil32(ceil32(_param4.length)) + 129 > LOCK8605463013():
                      revert with 0, 65
                  require _param4 + _param4.length + 36 <= calldata.size
                  if stor1 <= _param3:
                      revert with 0, 'ERC721A: owner query for nonexistent token'
                  if _param3 >= 2500:
                      if 1 > !(_param3 - 2500):
                          revert with 0, 17
          else:
              if isApprovedForAll(address owner, address operator) > uint32(call.func_hash):
                  if uint32(call.func_hash) != earlyPurchase(uint256 count, bytes32[] merkleProof):
                      if _maxPerAddress() == uint32(call.func_hash):
                          require not call.value
                          return _maxPerAddress
                      require totalReleased() == uint32(call.func_hash)
                      require not call.value
                      return totalReleased
                  require calldata.size - 4 >=′ 64
                  require _param2 <= LOCK8605463013()
                  require _param2 + 35 <′ calldata.size
                  require _param2.length <= LOCK8605463013()
                  require _param2 + (32 * _param2.length) + 36 <= calldata.size
                  if paused:
                      revert with 0, 'Pausable: paused'
                  if stor1 < 1:
                      revert with 0, 17
                  if stor1 - 1 > !_param1:
                      revert with 0, 17
                  if stor1 + _param1 - 1 > MAX_TOTAL_MINT:
                      revert with 0, 'BASE_COLLECTION/EXCEEDS_MAX_SUPPLY'
                  if _maxTxPerAddress:
                      if _param1 > _maxTxPerAddress:
                          revert with 0, 'BASE_COLLECTION/EXCEEDS_MAX_PER_TRANSACTION'
                  if stor28[caller] > !_param1:
                      revert with 0, 17
                  if _presaleMaxPerAddress:
                      if stor28[caller] + _param1 > _presaleMaxPerAddress:
                          revert with 0, 'BASE_COLLECTION/EXCEEDS_INDIVIDUAL_SUPPLY'
                  if _preSaleTime:
                      if _preSaleTime >= block.timestamp:
                          revert with 0, 'BASE_COLLECTION/CANNOT_MINT_PRESALE'
                      if block.timestamp >= _publicSaleTime:
                          revert with 0, 'BASE_COLLECTION/CANNOT_MINT_PRESALE'
              else:
                  if isApprovedForAll(address owner, address operator) == uint32(call.func_hash):
                      require not call.value
                      require calldata.size - 4 >=′ 64
                      require _param1 == address(_param1)
                      require _param2 == address(_param2)
                      return bool(stor7[address(_param1)][address(_param2)])
                  if uint32(call.func_hash) != purchase(uint256 _tokenId):
                      if uint32(call.func_hash) != transferOwnership(address newOwner):
                          require _preSaleTime() == uint32(call.func_hash)
                          require not call.value
                          return _preSaleTime
                      require not call.value
                      require calldata.size - 4 >=′ 32
                      require _param1 == address(_param1)
                      if owner != caller:
                          revert with 0, 'Ownable: caller is not the owner'
                      if not address(_param1):
                          revert with 0, 'Ownable: new owner is the zero address'
                      owner = address(_param1)
                      log OwnershipTransferred(
                            address previousOwner=owner,
                            address newOwner=address(_param1))
                      stop
                  require calldata.size - 4 >=′ 32
                  if paused:
                      revert with 0, 'Pausable: paused'
                  if stor1 < 1:
                      revert with 0, 17
                  if stor1 - 1 > !_param1:
                      revert with 0, 17
                  if stor1 + _param1 - 1 > MAX_TOTAL_MINT:
                      revert with 0, 'BASE_COLLECTION/EXCEEDS_MAX_SUPPLY'
                  if not _maxTxPerAddress:
                      if stor28[caller] > !_param1:
                          revert with 0, 17
                      if not _maxPerAddress:
                          if _publicSaleTime:
                              if _publicSaleTime >= block.timestamp:
                                  revert with 0, 'BASE_COLLECTION/CANNOT_MINT'
                          if _price and _param1 > -1 / _price:
                              revert with 0, 17
                          if _price * _param1 > call.value:
                              revert with 0, 'BASE_COLLECTION/INSUFFICIENT_ETH_AMOUNT'
                          if stor28[caller] > !_param1:
                              revert with 0, 17
                          stor28[caller] += _param1
                          if not caller:
                              revert with 0, 'ERC721A: mint to the zero address'
                          if stor1 > stor1:
                              revert with 0, 'ERC721A: token already minted'
                          if _param1 > 2500:
                              revert with 0, 'ERC721A: quantity to mint too high'
                          if balanceOf[caller].field_0 > -uint128(_param1) + LOCK8605463013():
                              revert with 0, 17
                          if balanceOf[caller].field_128 > -uint128(_param1) + LOCK8605463013():
                              revert with 0, 17
                          balanceOf[caller].field_0 = uint128(uint128(_param1) + balanceOf[caller].field_0)
                          balanceOf[caller].field_128 = uint128(uint128(_param1) + balanceOf[caller].field_128)
                          stor4[stor1].field_0 = caller
                          stor4[stor1].field_160 = uint64(block.timestamp)
                          if 0 >= _param1:
                              log Purchase(
                                    address holder=caller,
                                    uint256 tokenAmount=_price,
                                    uint256 etherAmount=_param1)
                              stop
                          log Transfer(
                                address from=0,
                                address to=caller,
                                uint256 value=stor1)
                          if not ext_code.size(caller):
                              if stor1 == -1:
                                  revert with 0, 17
                      else:
                          if stor28[caller] + _param1 > _maxPerAddress:
                              revert with 0, 'BASE_COLLECTION/EXCEEDS_INDIVIDUAL_SUPPLY'
                          if _publicSaleTime:
                              if _publicSaleTime >= block.timestamp:
                                  revert with 0, 'BASE_COLLECTION/CANNOT_MINT'
                          if _price and _param1 > -1 / _price:
                              revert with 0, 17
                          if _price * _param1 > call.value:
                              revert with 0, 'BASE_COLLECTION/INSUFFICIENT_ETH_AMOUNT'
                          if stor28[caller] > !_param1:
                              revert with 0, 17
                          stor28[caller] += _param1
                          if not caller:
                              revert with 0, 'ERC721A: mint to the zero address'
                          if stor1 > stor1:
                              revert with 0, 'ERC721A: token already minted'
                          if _param1 > 2500:
                              revert with 0, 'ERC721A: quantity to mint too high'
                          if balanceOf[caller].field_0 > -uint128(_param1) + LOCK8605463013():
                              revert with 0, 17
                          if balanceOf[caller].field_128 > -uint128(_param1) + LOCK8605463013():
                              revert with 0, 17
                          balanceOf[caller].field_0 = uint128(uint128(_param1) + balanceOf[caller].field_0)
                          balanceOf[caller].field_128 = uint128(uint128(_param1) + balanceOf[caller].field_128)
                          stor4[stor1].field_0 = caller
                          stor4[stor1].field_160 = uint64(block.timestamp)
                          if 0 >= _param1:
                              log Purchase(
                                    address holder=caller,
                                    uint256 tokenAmount=_price,
                                    uint256 etherAmount=_param1)
                              stop
                          log Transfer(
                                address from=0,
                                address to=caller,
                                uint256 value=stor1)
                          if not ext_code.size(caller):
                  else:
                      if _param1 > _maxTxPerAddress:
                          revert with 0, 'BASE_COLLECTION/EXCEEDS_MAX_PER_TRANSACTION'
                      if stor28[caller] > !_param1:
                          revert with 0, 17
                      if _maxPerAddress:
                          if stor28[caller] + _param1 > _maxPerAddress:
                              revert with 0, 'BASE_COLLECTION/EXCEEDS_INDIVIDUAL_SUPPLY'
                      if _publicSaleTime:
                          if _publicSaleTime >= block.timestamp:
                              revert with 0, 'BASE_COLLECTION/CANNOT_MINT'
                      if _price and _param1 > -1 / _price:
                          revert with 0, 17
                      if _price * _param1 > call.value:
                          revert with 0, 'BASE_COLLECTION/INSUFFICIENT_ETH_AMOUNT'
                      if stor28[caller] > !_param1:
                          revert with 0, 17
                      stor28[caller] += _param1
                      if not caller:
                          revert with 0, 'ERC721A: mint to the zero address'
                      if stor1 > stor1:
                          revert with 0, 'ERC721A: token already minted'
                      if _param1 > 2500:
                          revert with 0, 'ERC721A: quantity to mint too high'
                      if balanceOf[caller].field_0 > -uint128(_param1) + LOCK8605463013():
                          revert with 0, 17
                      if balanceOf[caller].field_128 > -uint128(_param1) + LOCK8605463013():
                          revert with 0, 17
                      balanceOf[caller].field_0 = uint128(uint128(_param1) + balanceOf[caller].field_0)
                      balanceOf[caller].field_128 = uint128(uint128(_param1) + balanceOf[caller].field_128)
                      stor4[stor1].field_0 = caller
                      stor4[stor1].field_160 = uint64(block.timestamp)
                      if 0 >= _param1:
                          log Purchase(
                                address holder=caller,
                                uint256 tokenAmount=_price,
                                uint256 etherAmount=_param1)
                          stop
                      log Transfer(
                            address from=0,
                            address to=caller,
                            uint256 value=stor1)
                      if not ext_code.size(caller):
  ...  # Decompilation aborted, sorry: ("decompilation didn't finish",)

def purchase(uint256 _tokenId) payable: 
  require calldata.size - 4 >=′ 32
  if paused:
      revert with 0, 'Pausable: paused'
  if stor1 < 1:
      revert with 0, 17
  if stor1 - 1 > !_tokenId:
      revert with 0, 17
  if stor1 + _tokenId - 1 > MAX_TOTAL_MINT:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'BASE_COLLECTION/EXCEEDS_MAX_SUPPLY'
  if not _maxTxPerAddress:
      if stor28[caller] > !_tokenId:
          revert with 0, 17
      if not _maxPerAddress:
          if not _publicSaleTime:
              if _price and _tokenId > -1 / _price:
                  revert with 0, 17
              if _price * _tokenId > call.value:
                  revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'BASE_COLLECTION/INSUFFICIENT_ETH_AMOUNT'
              if stor28[caller] > !_tokenId:
                  revert with 0, 17
              stor28[caller] += _tokenId
              mem[96] = 0
              if not caller:
                  revert with 0, 'ERC721A: mint to the zero address'
              if stor1 > stor1:
                  revert with 0, 'ERC721A: token already minted'
              if _tokenId > 2500:
                  revert with 0, 'ERC721A: quantity to mint too high'
              mem[128] = balanceOf[caller].field_0
              mem[160] = balanceOf[caller].field_128
              if balanceOf[caller].field_0 > -uint128(_tokenId) + LOCK8605463013():
                  revert with 0, 17
              mem[192] = uint128(uint128(_tokenId) + balanceOf[caller].field_0)
              if balanceOf[caller].field_128 > -uint128(_tokenId) + LOCK8605463013():
                  revert with 0, 17
              mem[224] = uint128(uint128(_tokenId) + balanceOf[caller].field_128)
              balanceOf[caller].field_0 = uint128(uint128(_tokenId) + balanceOf[caller].field_0)
              balanceOf[caller].field_128 = uint128(uint128(_tokenId) + balanceOf[caller].field_128)
              mem[64] = 320
              mem[256] = caller
              mem[288] = uint64(block.timestamp)
              mem[0] = stor1
              mem[32] = 4
              stor4[stor1].field_0 = caller
              stor4[stor1].field_160 = uint64(block.timestamp)
              idx = 0
              s = stor1
              while idx < _tokenId:
                  log Transfer(
                        address from=0,
                        address to=caller,
                        uint256 value=s)
                  if ext_code.size(caller):
                      mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                      mem[mem[64] + 4] = caller
                      mem[mem[64] + 36] = 0
                      mem[mem[64] + 68] = s
                      mem[mem[64] + 100] = 128
                      mem[mem[64] + 132] = mem[96]
                      t = 0
                      while t < mem[96]:
                          mem[t + mem[64] + 164] = mem[t + 128]
                          t = t + 32
                          continue 
                      if ceil32(mem[96]) <= mem[96]:
                          require ext_code.size(caller)
                          call caller.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, 0, s, 128, mem[96], mem[mem[64] + 164 len ceil32(mem[96])]
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if not mem[96]:
                                      revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                                  revert with memory
                                    from 128
                                     len mem[96]
                              if not return_data.size:
                                  revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                              revert with ext_call.return_data[0 len return_data.size]
                          _749 = mem[64]
                          mem[64] = mem[64] + ceil32(return_data.size)
                          require return_data.size >=′ 32
                          require mem[_749] == Mask(32, 224, mem[_749])
                          if Mask(32, 224, mem[_749]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
                              revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                      else:
                          mem[mem[96] + mem[64] + 164] = 0
                          require ext_code.size(caller)
                          call caller.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, 0, s, 128, mem[96], mem[mem[64] + 164 len ceil32(mem[96])]
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if not mem[96]:
                                      revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                                  revert with memory
                                    from 128
                                     len mem[96]
                              if not return_data.size:
                                  revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                              revert with ext_call.return_data[0 len return_data.size]
                          _750 = mem[64]
                          mem[64] = mem[64] + ceil32(return_data.size)
                          require return_data.size >=′ 32
                          require mem[_750] == Mask(32, 224, mem[_750])
                          if Mask(32, 224, mem[_750]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
                              revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                  if s == -1:
                      revert with 0, 17
                  if idx == -1:
                      revert with 0, 17
                  idx = idx + 1
                  s = s + 1
                  continue 
          else:
              if _publicSaleTime >= block.timestamp:
                  revert with 0, 'BASE_COLLECTION/CANNOT_MINT'
              if _price and _tokenId > -1 / _price:
                  revert with 0, 17
              if _price * _tokenId > call.value:
                  revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'BASE_COLLECTION/INSUFFICIENT_ETH_AMOUNT'
              if stor28[caller] > !_tokenId:
                  revert with 0, 17
              stor28[caller] += _tokenId
              mem[96] = 0
              if not caller:
                  revert with 0, 'ERC721A: mint to the zero address'
              if stor1 > stor1:
                  revert with 0, 'ERC721A: token already minted'
              if _tokenId > 2500:
                  revert with 0, 'ERC721A: quantity to mint too high'
              mem[128] = balanceOf[caller].field_0
              mem[160] = balanceOf[caller].field_128
              if balanceOf[caller].field_0 > -uint128(_tokenId) + LOCK8605463013():
                  revert with 0, 17
              mem[192] = uint128(uint128(_tokenId) + balanceOf[caller].field_0)
              if balanceOf[caller].field_128 > -uint128(_tokenId) + LOCK8605463013():
                  revert with 0, 17
              mem[224] = uint128(uint128(_tokenId) + balanceOf[caller].field_128)
              balanceOf[caller].field_0 = uint128(uint128(_tokenId) + balanceOf[caller].field_0)
              balanceOf[caller].field_128 = uint128(uint128(_tokenId) + balanceOf[caller].field_128)
              mem[64] = 320
              mem[256] = caller
              mem[288] = uint64(block.timestamp)
              mem[0] = stor1
              mem[32] = 4
              stor4[stor1].field_0 = caller
              stor4[stor1].field_160 = uint64(block.timestamp)
              idx = 0
              s = stor1
              while idx < _tokenId:
                  log Transfer(
                        address from=0,
                        address to=caller,
                        uint256 value=s)
                  if ext_code.size(caller):
                      mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                      mem[mem[64] + 4] = caller
                      mem[mem[64] + 36] = 0
                      mem[mem[64] + 68] = s
                      mem[mem[64] + 100] = 128
                      mem[mem[64] + 132] = mem[96]
                      t = 0
                      while t < mem[96]:
                          mem[t + mem[64] + 164] = mem[t + 128]
                          t = t + 32
                          continue 
                      if ceil32(mem[96]) <= mem[96]:
                          require ext_code.size(caller)
                          call caller.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, 0, s, 128, mem[96], mem[mem[64] + 164 len ceil32(mem[96])]
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if not mem[96]:
                                      revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                                  revert with memory
                                    from 128
                                     len mem[96]
                              if not return_data.size:
                                  revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                              revert with ext_call.return_data[0 len return_data.size]
                          _751 = mem[64]
                          mem[64] = mem[64] + ceil32(return_data.size)
                          require return_data.size >=′ 32
                          require mem[_751] == Mask(32, 224, mem[_751])
                          if Mask(32, 224, mem[_751]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
                              revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                      else:
                          mem[mem[96] + mem[64] + 164] = 0
                          require ext_code.size(caller)
                          call caller.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, 0, s, 128, mem[96], mem[mem[64] + 164 len ceil32(mem[96])]
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if not mem[96]:
                                      revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                                  revert with memory
                                    from 128
                                     len mem[96]
                              if not return_data.size:
                                  revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                              revert with ext_call.return_data[0 len return_data.size]
                          _752 = mem[64]
                          mem[64] = mem[64] + ceil32(return_data.size)
                          require return_data.size >=′ 32
                          require mem[_752] == Mask(32, 224, mem[_752])
                          if Mask(32, 224, mem[_752]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
                              revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                  if s == -1:
                      revert with 0, 17
                  if idx == -1:
                      revert with 0, 17
                  idx = idx + 1
                  s = s + 1
                  continue 
      else:
          if stor28[caller] + _tokenId > _maxPerAddress:
              revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'BASE_COLLECTION/EXCEEDS_INDIVIDUAL_SUPPLY'
          if not _publicSaleTime:
              if _price and _tokenId > -1 / _price:
                  revert with 0, 17
              if _price * _tokenId > call.value:
                  revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'BASE_COLLECTION/INSUFFICIENT_ETH_AMOUNT'
              if stor28[caller] > !_tokenId:
                  revert with 0, 17
              stor28[caller] += _tokenId
              mem[96] = 0
              if not caller:
                  revert with 0, 'ERC721A: mint to the zero address'
              if stor1 > stor1:
                  revert with 0, 'ERC721A: token already minted'
              if _tokenId > 2500:
                  revert with 0, 'ERC721A: quantity to mint too high'
              mem[128] = balanceOf[caller].field_0
              mem[160] = balanceOf[caller].field_128
              if balanceOf[caller].field_0 > -uint128(_tokenId) + LOCK8605463013():
                  revert with 0, 17
              mem[192] = uint128(uint128(_tokenId) + balanceOf[caller].field_0)
              if balanceOf[caller].field_128 > -uint128(_tokenId) + LOCK8605463013():
                  revert with 0, 17
              mem[224] = uint128(uint128(_tokenId) + balanceOf[caller].field_128)
              balanceOf[caller].field_0 = uint128(uint128(_tokenId) + balanceOf[caller].field_0)
              balanceOf[caller].field_128 = uint128(uint128(_tokenId) + balanceOf[caller].field_128)
              mem[64] = 320
              mem[256] = caller
              mem[288] = uint64(block.timestamp)
              mem[0] = stor1
              mem[32] = 4
              stor4[stor1].field_0 = caller
              stor4[stor1].field_160 = uint64(block.timestamp)
              idx = 0
              s = stor1
              while idx < _tokenId:
                  log Transfer(
                        address from=0,
                        address to=caller,
                        uint256 value=s)
                  if ext_code.size(caller):
                      mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                      mem[mem[64] + 4] = caller
                      mem[mem[64] + 36] = 0
                      mem[mem[64] + 68] = s
                      mem[mem[64] + 100] = 128
                      mem[mem[64] + 132] = mem[96]
                      t = 0
                      while t < mem[96]:
                          mem[t + mem[64] + 164] = mem[t + 128]
                          t = t + 32
                          continue 
                      if ceil32(mem[96]) <= mem[96]:
                          require ext_code.size(caller)
                          call caller.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, 0, s, 128, mem[96], mem[mem[64] + 164 len ceil32(mem[96])]
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if not mem[96]:
                                      revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                                  revert with memory
                                    from 128
                                     len mem[96]
                              if not return_data.size:
                                  revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                              revert with ext_call.return_data[0 len return_data.size]
                          _753 = mem[64]
                          mem[64] = mem[64] + ceil32(return_data.size)
                          require return_data.size >=′ 32
                          require mem[_753] == Mask(32, 224, mem[_753])
                          if Mask(32, 224, mem[_753]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
                              revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                      else:
                          mem[mem[96] + mem[64] + 164] = 0
                          require ext_code.size(caller)
                          call caller.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, 0, s, 128, mem[96], mem[mem[64] + 164 len ceil32(mem[96])]
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if not mem[96]:
                                      revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                                  revert with memory
                                    from 128
                                     len mem[96]
                              if not return_data.size:
                                  revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                              revert with ext_call.return_data[0 len return_data.size]
                          _754 = mem[64]
                          mem[64] = mem[64] + ceil32(return_data.size)
                          require return_data.size >=′ 32
                          require mem[_754] == Mask(32, 224, mem[_754])
                          if Mask(32, 224, mem[_754]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
                              revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                  if s == -1:
                      revert with 0, 17
                  if idx == -1:
                      revert with 0, 17
                  idx = idx + 1
                  s = s + 1
                  continue 
          else:
              if _publicSaleTime >= block.timestamp:
                  revert with 0, 'BASE_COLLECTION/CANNOT_MINT'
              if _price and _tokenId > -1 / _price:
                  revert with 0, 17
              if _price * _tokenId > call.value:
                  revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'BASE_COLLECTION/INSUFFICIENT_ETH_AMOUNT'
              if stor28[caller] > !_tokenId:
                  revert with 0, 17
              stor28[caller] += _tokenId
              mem[96] = 0
              if not caller:
                  revert with 0, 'ERC721A: mint to the zero address'
              if stor1 > stor1:
                  revert with 0, 'ERC721A: token already minted'
              if _tokenId > 2500:
                  revert with 0, 'ERC721A: quantity to mint too high'
              mem[128] = balanceOf[caller].field_0
              mem[160] = balanceOf[caller].field_128
              if balanceOf[caller].field_0 > -uint128(_tokenId) + LOCK8605463013():
                  revert with 0, 17
              mem[192] = uint128(uint128(_tokenId) + balanceOf[caller].field_0)
              if balanceOf[caller].field_128 > -uint128(_tokenId) + LOCK8605463013():
                  revert with 0, 17
              mem[224] = uint128(uint128(_tokenId) + balanceOf[caller].field_128)
              balanceOf[caller].field_0 = uint128(uint128(_tokenId) + balanceOf[caller].field_0)
              balanceOf[caller].field_128 = uint128(uint128(_tokenId) + balanceOf[caller].field_128)
              mem[64] = 320
              mem[256] = caller
              mem[288] = uint64(block.timestamp)
              mem[0] = stor1
              mem[32] = 4
              stor4[stor1].field_0 = caller
              stor4[stor1].field_160 = uint64(block.timestamp)
              idx = 0
              s = stor1
              while idx < _tokenId:
                  log Transfer(
                        address from=0,
                        address to=caller,
                        uint256 value=s)
                  if ext_code.size(caller):
                      mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                      mem[mem[64] + 4] = caller
                      mem[mem[64] + 36] = 0
                      mem[mem[64] + 68] = s
                      mem[mem[64] + 100] = 128
                      mem[mem[64] + 132] = mem[96]
                      t = 0
                      while t < mem[96]:
                          mem[t + mem[64] + 164] = mem[t + 128]
                          t = t + 32
                          continue 
                      if ceil32(mem[96]) <= mem[96]:
                          require ext_code.size(caller)
                          call caller.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, 0, s, 128, mem[96], mem[mem[64] + 164 len ceil32(mem[96])]
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if not mem[96]:
                                      revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                                  revert with memory
                                    from 128
                                     len mem[96]
                              if not return_data.size:
                                  revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                              revert with ext_call.return_data[0 len return_data.size]
                          _755 = mem[64]
                          mem[64] = mem[64] + ceil32(return_data.size)
                          require return_data.size >=′ 32
                          require mem[_755] == Mask(32, 224, mem[_755])
                          if Mask(32, 224, mem[_755]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
                              revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                      else:
                          mem[mem[96] + mem[64] + 164] = 0
                          require ext_code.size(caller)
                          call caller.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, 0, s, 128, mem[96], mem[mem[64] + 164 len ceil32(mem[96])]
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if not mem[96]:
                                      revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                                  revert with memory
                                    from 128
                                     len mem[96]
                              if not return_data.size:
                                  revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                              revert with ext_call.return_data[0 len return_data.size]
                          _756 = mem[64]
                          mem[64] = mem[64] + ceil32(return_data.size)
                          require return_data.size >=′ 32
                          require mem[_756] == Mask(32, 224, mem[_756])
                          if Mask(32, 224, mem[_756]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
                              revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                  if s == -1:
                      revert with 0, 17
                  if idx == -1:
                      revert with 0, 17
                  idx = idx + 1
                  s = s + 1
                  continue 
  else:
      if _tokenId > _maxTxPerAddress:
          revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'BASE_COLLECTION/EXCEEDS_MAX_PER_TRANSACTION'
      if stor28[caller] > !_tokenId:
          revert with 0, 17
      if not _maxPerAddress:
          if not _publicSaleTime:
              if _price and _tokenId > -1 / _price:
                  revert with 0, 17
              if _price * _tokenId > call.value:
                  revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'BASE_COLLECTION/INSUFFICIENT_ETH_AMOUNT'
              if stor28[caller] > !_tokenId:
                  revert with 0, 17
              stor28[caller] += _tokenId
              mem[96] = 0
              if not caller:
                  revert with 0, 'ERC721A: mint to the zero address'
              if stor1 > stor1:
                  revert with 0, 'ERC721A: token already minted'
              if _tokenId > 2500:
                  revert with 0, 'ERC721A: quantity to mint too high'
              mem[128] = balanceOf[caller].field_0
              mem[160] = balanceOf[caller].field_128
              if balanceOf[caller].field_0 > -uint128(_tokenId) + LOCK8605463013():
                  revert with 0, 17
              mem[192] = uint128(uint128(_tokenId) + balanceOf[caller].field_0)
              if balanceOf[caller].field_128 > -uint128(_tokenId) + LOCK8605463013():
                  revert with 0, 17
              mem[224] = uint128(uint128(_tokenId) + balanceOf[caller].field_128)
              balanceOf[caller].field_0 = uint128(uint128(_tokenId) + balanceOf[caller].field_0)
              balanceOf[caller].field_128 = uint128(uint128(_tokenId) + balanceOf[caller].field_128)
              mem[64] = 320
              mem[256] = caller
              mem[288] = uint64(block.timestamp)
              mem[0] = stor1
              mem[32] = 4
              stor4[stor1].field_0 = caller
              stor4[stor1].field_160 = uint64(block.timestamp)
              idx = 0
              s = stor1
              while idx < _tokenId:
                  log Transfer(
                        address from=0,
                        address to=caller,
                        uint256 value=s)
                  if ext_code.size(caller):
                      mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                      mem[mem[64] + 4] = caller
                      mem[mem[64] + 36] = 0
                      mem[mem[64] + 68] = s
                      mem[mem[64] + 100] = 128
                      mem[mem[64] + 132] = mem[96]
                      t = 0
                      while t < mem[96]:
                          mem[t + mem[64] + 164] = mem[t + 128]
                          t = t + 32
                          continue 
                      if ceil32(mem[96]) <= mem[96]:
                          require ext_code.size(caller)
                          call caller.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, 0, s, 128, mem[96], mem[mem[64] + 164 len ceil32(mem[96])]
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if not mem[96]:
                                      revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                                  revert with memory
                                    from 128
                                     len mem[96]
                              if not return_data.size:
                                  revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                              revert with ext_call.return_data[0 len return_data.size]
                          _757 = mem[64]
                          mem[64] = mem[64] + ceil32(return_data.size)
                          require return_data.size >=′ 32
                          require mem[_757] == Mask(32, 224, mem[_757])
                          if Mask(32, 224, mem[_757]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
                              revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                      else:
                          mem[mem[96] + mem[64] + 164] = 0
                          require ext_code.size(caller)
                          call caller.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, 0, s, 128, mem[96], mem[mem[64] + 164 len ceil32(mem[96])]
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if not mem[96]:
                                      revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                                  revert with memory
                                    from 128
                                     len mem[96]
                              if not return_data.size:
                                  revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                              revert with ext_call.return_data[0 len return_data.size]
                          _758 = mem[64]
                          mem[64] = mem[64] + ceil32(return_data.size)
                          require return_data.size >=′ 32
                          require mem[_758] == Mask(32, 224, mem[_758])
                          if Mask(32, 224, mem[_758]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
                              revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                  if s == -1:
                      revert with 0, 17
                  if idx == -1:
                      revert with 0, 17
                  idx = idx + 1
                  s = s + 1
                  continue 
          else:
              if _publicSaleTime >= block.timestamp:
                  revert with 0, 'BASE_COLLECTION/CANNOT_MINT'
              if _price and _tokenId > -1 / _price:
                  revert with 0, 17
              if _price * _tokenId > call.value:
                  revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'BASE_COLLECTION/INSUFFICIENT_ETH_AMOUNT'
              if stor28[caller] > !_tokenId:
                  revert with 0, 17
              stor28[caller] += _tokenId
              mem[96] = 0
              if not caller:
                  revert with 0, 'ERC721A: mint to the zero address'
              if stor1 > stor1:
                  revert with 0, 'ERC721A: token already minted'
              if _tokenId > 2500:
                  revert with 0, 'ERC721A: quantity to mint too high'
              mem[128] = balanceOf[caller].field_0
              mem[160] = balanceOf[caller].field_128
              if balanceOf[caller].field_0 > -uint128(_tokenId) + LOCK8605463013():
                  revert with 0, 17
              mem[192] = uint128(uint128(_tokenId) + balanceOf[caller].field_0)
              if balanceOf[caller].field_128 > -uint128(_tokenId) + LOCK8605463013():
                  revert with 0, 17
              mem[224] = uint128(uint128(_tokenId) + balanceOf[caller].field_128)
              balanceOf[caller].field_0 = uint128(uint128(_tokenId) + balanceOf[caller].field_0)
              balanceOf[caller].field_128 = uint128(uint128(_tokenId) + balanceOf[caller].field_128)
              mem[64] = 320
              mem[256] = caller
              mem[288] = uint64(block.timestamp)
              mem[0] = stor1
              mem[32] = 4
              stor4[stor1].field_0 = caller
              stor4[stor1].field_160 = uint64(block.timestamp)
              idx = 0
              s = stor1
              while idx < _tokenId:
                  log Transfer(
                        address from=0,
                        address to=caller,
                        uint256 value=s)
                  if ext_code.size(caller):
                      mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                      mem[mem[64] + 4] = caller
                      mem[mem[64] + 36] = 0
                      mem[mem[64] + 68] = s
                      mem[mem[64] + 100] = 128
                      mem[mem[64] + 132] = mem[96]
                      t = 0
                      while t < mem[96]:
                          mem[t + mem[64] + 164] = mem[t + 128]
                          t = t + 32
                          continue 
                      if ceil32(mem[96]) <= mem[96]:
                          require ext_code.size(caller)
                          call caller.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, 0, s, 128, mem[96], mem[mem[64] + 164 len ceil32(mem[96])]
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if not mem[96]:
                                      revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                                  revert with memory
                                    from 128
                                     len mem[96]
                              if not return_data.size:
                                  revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                              revert with ext_call.return_data[0 len return_data.size]
                          _759 = mem[64]
                          mem[64] = mem[64] + ceil32(return_data.size)
                          require return_data.size >=′ 32
                          require mem[_759] == Mask(32, 224, mem[_759])
                          if Mask(32, 224, mem[_759]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
                              revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                      else:
                          mem[mem[96] + mem[64] + 164] = 0
                          require ext_code.size(caller)
                          call caller.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, 0, s, 128, mem[96], mem[mem[64] + 164 len ceil32(mem[96])]
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if not mem[96]:
                                      revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                                  revert with memory
                                    from 128
                                     len mem[96]
                              if not return_data.size:
                                  revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                              revert with ext_call.return_data[0 len return_data.size]
                          _760 = mem[64]
                          mem[64] = mem[64] + ceil32(return_data.size)
                          require return_data.size >=′ 32
                          require mem[_760] == Mask(32, 224, mem[_760])
                          if Mask(32, 224, mem[_760]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
                              revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                  if s == -1:
                      revert with 0, 17
                  if idx == -1:
                      revert with 0, 17
                  idx = idx + 1
                  s = s + 1
                  continue 
      else:
          if stor28[caller] + _tokenId > _maxPerAddress:
              revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'BASE_COLLECTION/EXCEEDS_INDIVIDUAL_SUPPLY'
          if not _publicSaleTime:
              if _price and _tokenId > -1 / _price:
                  revert with 0, 17
              if _price * _tokenId > call.value:
                  revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'BASE_COLLECTION/INSUFFICIENT_ETH_AMOUNT'
              if stor28[caller] > !_tokenId:
                  revert with 0, 17
              stor28[caller] += _tokenId
              mem[96] = 0
              if not caller:
                  revert with 0, 'ERC721A: mint to the zero address'
              if stor1 > stor1:
                  revert with 0, 'ERC721A: token already minted'
              if _tokenId > 2500:
                  revert with 0, 'ERC721A: quantity to mint too high'
              mem[128] = balanceOf[caller].field_0
              mem[160] = balanceOf[caller].field_128
              if balanceOf[caller].field_0 > -uint128(_tokenId) + LOCK8605463013():
                  revert with 0, 17
              mem[192] = uint128(uint128(_tokenId) + balanceOf[caller].field_0)
              if balanceOf[caller].field_128 > -uint128(_tokenId) + LOCK8605463013():
                  revert with 0, 17
              mem[224] = uint128(uint128(_tokenId) + balanceOf[caller].field_128)
              balanceOf[caller].field_0 = uint128(uint128(_tokenId) + balanceOf[caller].field_0)
              balanceOf[caller].field_128 = uint128(uint128(_tokenId) + balanceOf[caller].field_128)
              mem[64] = 320
              mem[256] = caller
              mem[288] = uint64(block.timestamp)
              mem[0] = stor1
              mem[32] = 4
              stor4[stor1].field_0 = caller
              stor4[stor1].field_160 = uint64(block.timestamp)
              idx = 0
              s = stor1
              while idx < _tokenId:
                  log Transfer(
                        address from=0,
                        address to=caller,
                        uint256 value=s)
                  if ext_code.size(caller):
                      mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                      mem[mem[64] + 4] = caller
                      mem[mem[64] + 36] = 0
                      mem[mem[64] + 68] = s
                      mem[mem[64] + 100] = 128
                      mem[mem[64] + 132] = mem[96]
                      t = 0
                      while t < mem[96]:
                          mem[t + mem[64] + 164] = mem[t + 128]
                          t = t + 32
                          continue 
                      if ceil32(mem[96]) <= mem[96]:
                          require ext_code.size(caller)
                          call caller.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, 0, s, 128, mem[96], mem[mem[64] + 164 len ceil32(mem[96])]
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if not mem[96]:
                                      revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                                  revert with memory
                                    from 128
                                     len mem[96]
                              if not return_data.size:
                                  revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                              revert with ext_call.return_data[0 len return_data.size]
                          _761 = mem[64]
                          mem[64] = mem[64] + ceil32(return_data.size)
                          require return_data.size >=′ 32
                          require mem[_761] == Mask(32, 224, mem[_761])
                          if Mask(32, 224, mem[_761]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
                              revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                      else:
                          mem[mem[96] + mem[64] + 164] = 0
                          require ext_code.size(caller)
                          call caller.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, 0, s, 128, mem[96], mem[mem[64] + 164 len ceil32(mem[96])]
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if not mem[96]:
                                      revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                                  revert with memory
                                    from 128
                                     len mem[96]
                              if not return_data.size:
                                  revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                              revert with ext_call.return_data[0 len return_data.size]
                          _762 = mem[64]
                          mem[64] = mem[64] + ceil32(return_data.size)
                          require return_data.size >=′ 32
                          require mem[_762] == Mask(32, 224, mem[_762])
                          if Mask(32, 224, mem[_762]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
                              revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                  if s == -1:
                      revert with 0, 17
                  if idx == -1:
                      revert with 0, 17
                  idx = idx + 1
                  s = s + 1
                  continue 
          else:
              if _publicSaleTime >= block.timestamp:
                  revert with 0, 'BASE_COLLECTION/CANNOT_MINT'
              if _price and _tokenId > -1 / _price:
                  revert with 0, 17
              if _price * _tokenId > call.value:
                  revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'BASE_COLLECTION/INSUFFICIENT_ETH_AMOUNT'
              if stor28[caller] > !_tokenId:
                  revert with 0, 17
              stor28[caller] += _tokenId
              mem[96] = 0
              if not caller:
                  revert with 0, 'ERC721A: mint to the zero address'
              if stor1 > stor1:
                  revert with 0, 'ERC721A: token already minted'
              if _tokenId > 2500:
                  revert with 0, 'ERC721A: quantity to mint too high'
              mem[128] = balanceOf[caller].field_0
              mem[160] = balanceOf[caller].field_128
              if balanceOf[caller].field_0 > -uint128(_tokenId) + LOCK8605463013():
                  revert with 0, 17
              mem[192] = uint128(uint128(_tokenId) + balanceOf[caller].field_0)
              if balanceOf[caller].field_128 > -uint128(_tokenId) + LOCK8605463013():
                  revert with 0, 17
              mem[224] = uint128(uint128(_tokenId) + balanceOf[caller].field_128)
              balanceOf[caller].field_0 = uint128(uint128(_tokenId) + balanceOf[caller].field_0)
              balanceOf[caller].field_128 = uint128(uint128(_tokenId) + balanceOf[caller].field_128)
              mem[64] = 320
              mem[256] = caller
              mem[288] = uint64(block.timestamp)
              mem[0] = stor1
              mem[32] = 4
              stor4[stor1].field_0 = caller
              stor4[stor1].field_160 = uint64(block.timestamp)
              idx = 0
              s = stor1
              while idx < _tokenId:
                  log Transfer(
                        address from=0,
                        address to=caller,
                        uint256 value=s)
                  if ext_code.size(caller):
                      mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                      mem[mem[64] + 4] = caller
                      mem[mem[64] + 36] = 0
                      mem[mem[64] + 68] = s
                      mem[mem[64] + 100] = 128
                      mem[mem[64] + 132] = mem[96]
                      t = 0
                      while t < mem[96]:
                          mem[t + mem[64] + 164] = mem[t + 128]
                          t = t + 32
                          continue 
                      if ceil32(mem[96]) <= mem[96]:
                          require ext_code.size(caller)
                          call caller.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, 0, s, 128, mem[96], mem[mem[64] + 164 len ceil32(mem[96])]
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if not mem[96]:
                                      revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                                  revert with memory
                                    from 128
                                     len mem[96]
                              if not return_data.size:
                                  revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                              revert with ext_call.return_data[0 len return_data.size]
                          _763 = mem[64]
                          mem[64] = mem[64] + ceil32(return_data.size)
                          require return_data.size >=′ 32
                          require mem[_763] == Mask(32, 224, mem[_763])
                          if Mask(32, 224, mem[_763]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
                              revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                      else:
                          mem[mem[96] + mem[64] + 164] = 0
                          require ext_code.size(caller)
                          call caller.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, 0, s, 128, mem[96], mem[mem[64] + 164 len ceil32(mem[96])]
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if not mem[96]:
                                      revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                                  revert with memory
                                    from 128
                                     len mem[96]
                              if not return_data.size:
                                  revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                              revert with ext_call.return_data[0 len return_data.size]
                          _764 = mem[64]
                          mem[64] = mem[64] + ceil32(return_data.size)
                          require return_data.size >=′ 32
                          require mem[_764] == Mask(32, 224, mem[_764])
                          if Mask(32, 224, mem[_764]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
                              revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                  if s == -1:
                      revert with 0, 17
                  if idx == -1:
                      revert with 0, 17
                  idx = idx + 1
                  s = s + 1
                  continue 
  stor1 = s
  log Purchase(
        address holder=caller,
        uint256 tokenAmount=_price,
        uint256 etherAmount=_tokenId)

def earlyPurchase(uint256 count, bytes32[] merkleProof) payable: 
  require calldata.size - 4 >=′ 64
  require merkleProof <= LOCK8605463013()
  require merkleProof + 35 <′ calldata.size
  require merkleProof.length <= LOCK8605463013()
  require merkleProof + (32 * merkleProof.length) + 36 <= calldata.size
  if paused:
      revert with 0, 'Pausable: paused'
  if stor1 < 1:
      revert with 0, 17
  if stor1 - 1 > !count:
      revert with 0, 17
  if stor1 + count - 1 > MAX_TOTAL_MINT:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'BASE_COLLECTION/EXCEEDS_MAX_SUPPLY'
  if not _maxTxPerAddress:
      mem[0] = caller
      mem[32] = 28
      if stor28[caller] > !count:
          revert with 0, 17
      if not _presaleMaxPerAddress:
          if not _preSaleTime:
              mem[128] = caller
              mem[96] = 20
              mem[64] = (32 * merkleProof.length) + 180
              mem[148] = merkleProof.length
              mem[180 len 32 * merkleProof.length] = call.data[merkleProof + 36 len 32 * merkleProof.length]
              mem[(32 * merkleProof.length) + 180] = 0
              idx = 0
              s = 0
              while idx < merkleProof.length:
                  if idx >= mem[148]:
                      revert with 0, 50
                  _629 = mem[(32 * idx) + 180]
                  if s + sha3(mem[128 len 20]) > mem[(32 * idx) + 180]:
                      mem[mem[64] + 32] = mem[(32 * idx) + 180]
                      mem[mem[64] + 64] = s + sha3(mem[128 len 20])
                      _638 = mem[64]
                      mem[mem[64]] = 64
                      mem[64] = mem[64] + 96
                      if idx == -1:
                          revert with 0, 17
                      idx = idx + 1
                      s = sha3(mem[_638 + 32 len mem[_638]])
                      continue 
                  mem[mem[64] + 32] = s + sha3(mem[128 len 20])
                  mem[mem[64] + 64] = _629
                  _642 = mem[64]
                  mem[mem[64]] = 64
                  mem[64] = mem[64] + 96
                  if idx == -1:
                      revert with 0, 17
                  idx = idx + 1
                  s = sha3(mem[_642 + 32 len mem[_642]])
                  continue 
              if s != _merkleRoot:
                  revert with 0, 'BASE_COLLECTION/CANNOT_MINT_PRESALE'
              if _presalePrice and count > -1 / _presalePrice:
                  revert with 0, 17
              if _presalePrice * count > call.value:
                  revert with 0, 'BASE_COLLECTION/INSUFFICIENT_ETH_AMOUNT'
              mem[0] = caller
              if stor28[caller] > !count:
                  revert with 0, 17
              stor28[caller] += count
              _741 = mem[64]
              mem[64] = mem[64] + 32
              mem[_741] = 0
              if not caller:
                  revert with 0, 'ERC721A: mint to the zero address'
              if stor1 > stor1:
                  revert with 0, 'ERC721A: token already minted'
              if count > 2500:
                  revert with 0, 'ERC721A: quantity to mint too high'
              mem[0] = caller
              mem[32] = 5
              _774 = mem[64]
              mem[64] = mem[64] + 64
              mem[_774] = balanceOf[caller].field_0
              mem[_774 + 32] = balanceOf[caller].field_128
              _775 = mem[64]
              mem[64] = mem[64] + 64
              if balanceOf[caller].field_0 > -uint128(count) + LOCK8605463013():
                  revert with 0, 17
              mem[_775] = uint128(uint128(count) + balanceOf[caller].field_0)
              if balanceOf[caller].field_128 > -uint128(count) + LOCK8605463013():
                  revert with 0, 17
              mem[_775 + 32] = uint128(uint128(count) + balanceOf[caller].field_128)
              mem[0] = caller
              mem[32] = 5
              balanceOf[caller].field_0 = uint128(uint128(count) + balanceOf[caller].field_0)
              balanceOf[caller].field_128 = uint128(uint128(count) + balanceOf[caller].field_128)
              _840 = mem[64]
              mem[64] = mem[64] + 64
              mem[_840] = caller
              mem[_840 + 32] = uint64(block.timestamp)
              mem[0] = stor1
              mem[32] = 4
              stor4[stor1].field_0 = caller
              stor4[stor1].field_160 = uint64(block.timestamp)
              idx = 0
              s = stor1
              while idx < count:
                  log Transfer(
                        address from=0,
                        address to=caller,
                        uint256 value=s)
                  if not ext_code.size(caller):
                      if s == -1:
                          revert with 0, 17
                      if idx == -1:
                          revert with 0, 17
                      idx = idx + 1
                      s = s + 1
                      continue 
                  mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                  mem[mem[64] + 4] = caller
                  mem[mem[64] + 36] = 0
                  mem[mem[64] + 68] = s
                  mem[mem[64] + 100] = 128
                  mem[mem[64] + 132] = 0
                  idx = 0
                  while idx < 0:
                      mem[idx + mem[64] + 164] = mem[idx + _741 + 32]
                      idx = idx + 32
                      continue 
                  require ext_code.size(caller)
                  call caller.onERC721Received(address , address , uint256 , bytes ) with:
                       gas gas_remaining wei
                      args caller, 0, s, 128, 0
                  mem[mem[64]] = ext_call.return_data[0]
                  if not ext_call.success:
                      if not return_data.size:
                          if not mem[96]:
                              revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                          revert with memory
                            from 128
                             len mem[96]
                      if not return_data.size:
                          revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                      revert with ext_call.return_data[0 len return_data.size]
                  _1445 = mem[64]
                  mem[64] = mem[64] + ceil32(return_data.size)
                  require return_data.size >=′ 32
                  require mem[_1445] == Mask(32, 224, mem[_1445])
                  if 0x150b7a0200000000000000000000000000000000000000000000000000000000 == Mask(32, 224, mem[_1445]):
                  ...  # Decompilation aborted, sorry: ("decompilation didn't finish",)
          else:
              if _preSaleTime >= block.timestamp:
                  revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'BASE_COLLECTION/CANNOT_MINT_PRESALE'
              if block.timestamp >= _publicSaleTime:
                  revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'BASE_COLLECTION/CANNOT_MINT_PRESALE'
              mem[128] = caller
              mem[96] = 20
              mem[64] = (32 * merkleProof.length) + 180
              mem[148] = merkleProof.length
              mem[180 len 32 * merkleProof.length] = call.data[merkleProof + 36 len 32 * merkleProof.length]
              mem[(32 * merkleProof.length) + 180] = 0
              idx = 0
              s = 0
              while idx < merkleProof.length:
                  if idx >= mem[148]:
                      revert with 0, 50
                  _630 = mem[(32 * idx) + 180]
                  if s + sha3(mem[128 len 20]) > mem[(32 * idx) + 180]:
                      mem[mem[64] + 32] = mem[(32 * idx) + 180]
                      mem[mem[64] + 64] = s + sha3(mem[128 len 20])
                      _646 = mem[64]
                      mem[mem[64]] = 64
                      mem[64] = mem[64] + 96
                      if idx == -1:
                          revert with 0, 17
                      idx = idx + 1
                      s = sha3(mem[_646 + 32 len mem[_646]])
                      continue 
                  mem[mem[64] + 32] = s + sha3(mem[128 len 20])
                  mem[mem[64] + 64] = _630
                  _650 = mem[64]
                  mem[mem[64]] = 64
                  mem[64] = mem[64] + 96
                  if idx == -1:
                      revert with 0, 17
                  idx = idx + 1
                  s = sha3(mem[_650 + 32 len mem[_650]])
                  continue 
              if s != _merkleRoot:
                  revert with 0, 'BASE_COLLECTION/CANNOT_MINT_PRESALE'
              if _presalePrice and count > -1 / _presalePrice:
                  revert with 0, 17
              if _presalePrice * count > call.value:
                  revert with 0, 'BASE_COLLECTION/INSUFFICIENT_ETH_AMOUNT'
              mem[0] = caller
              if stor28[caller] > !count:
                  revert with 0, 17
              stor28[caller] += count
              _742 = mem[64]
              mem[64] = mem[64] + 32
              mem[_742] = 0
              if not caller:
                  revert with 0, 'ERC721A: mint to the zero address'
              if stor1 > stor1:
                  revert with 0, 'ERC721A: token already minted'
              if count > 2500:
                  revert with 0, 'ERC721A: quantity to mint too high'
              mem[0] = caller
              mem[32] = 5
              _780 = mem[64]
              mem[64] = mem[64] + 64
              mem[_780] = balanceOf[caller].field_0
              mem[_780 + 32] = balanceOf[caller].field_128
              _781 = mem[64]
              mem[64] = mem[64] + 64
              if balanceOf[caller].field_0 > -uint128(count) + LOCK8605463013():
                  revert with 0, 17
              mem[_781] = uint128(uint128(count) + balanceOf[caller].field_0)
              if balanceOf[caller].field_128 > -uint128(count) + LOCK8605463013():
                  revert with 0, 17
              mem[_781 + 32] = uint128(uint128(count) + balanceOf[caller].field_128)
              mem[0] = caller
              mem[32] = 5
              balanceOf[caller].field_0 = uint128(uint128(count) + balanceOf[caller].field_0)
              balanceOf[caller].field_128 = uint128(uint128(count) + balanceOf[caller].field_128)
              _847 = mem[64]
              mem[64] = mem[64] + 64
              mem[_847] = caller
              mem[_847 + 32] = uint64(block.timestamp)
              mem[0] = stor1
              mem[32] = 4
              stor4[stor1].field_0 = caller
              stor4[stor1].field_160 = uint64(block.timestamp)
              idx = 0
              s = stor1
              while idx < count:
                  log Transfer(
                        address from=0,
                        address to=caller,
                        uint256 value=s)
                  if not ext_code.size(caller):
                      if s == -1:
                          revert with 0, 17
                      if idx == -1:
                          revert with 0, 17
                      idx = idx + 1
                      s = s + 1
                      continue 
                  mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                  mem[mem[64] + 4] = caller
                  mem[mem[64] + 36] = 0
                  mem[mem[64] + 68] = s
                  mem[mem[64] + 100] = 128
                  mem[mem[64] + 132] = 0
                  idx = 0
                  while idx < 0:
                      mem[idx + mem[64] + 164] = mem[idx + _742 + 32]
                      idx = idx + 32
                      continue 
                  require ext_code.size(caller)
                  call caller.onERC721Received(address , address , uint256 , bytes ) with:
                       gas gas_remaining wei
                      args caller, 0, s, 128, 0
                  mem[mem[64]] = ext_call.return_data[0]
                  if not ext_call.success:
                      if not return_data.size:
                          if not mem[96]:
                              revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                          revert with memory
                            from 128
                             len mem[96]
                      if not return_data.size:
                          revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                      revert with ext_call.return_data[0 len return_data.size]
                  _1447 = mem[64]
                  mem[64] = mem[64] + ceil32(return_data.size)
                  require return_data.size >=′ 32
                  require mem[_1447] == Mask(32, 224, mem[_1447])
                  if 0x150b7a0200000000000000000000000000000000000000000000000000000000 == Mask(32, 224, mem[_1447]):
                  ...  # Decompilation aborted, sorry: ("decompilation didn't finish",)
      else:
          if stor28[caller] + count > _presaleMaxPerAddress:
              revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'BASE_COLLECTION/EXCEEDS_INDIVIDUAL_SUPPLY'
          if not _preSaleTime:
              mem[128] = caller
              mem[96] = 20
              mem[64] = (32 * merkleProof.length) + 180
              mem[148] = merkleProof.length
              mem[180 len 32 * merkleProof.length] = call.data[merkleProof + 36 len 32 * merkleProof.length]
              mem[(32 * merkleProof.length) + 180] = 0
              idx = 0
              s = 0
              while idx < merkleProof.length:
                  if idx >= mem[148]:
                      revert with 0, 50
                  _631 = mem[(32 * idx) + 180]
                  if s + sha3(mem[128 len 20]) > mem[(32 * idx) + 180]:
                      mem[mem[64] + 32] = mem[(32 * idx) + 180]
                      mem[mem[64] + 64] = s + sha3(mem[128 len 20])
                      _654 = mem[64]
                      mem[mem[64]] = 64
                      mem[64] = mem[64] + 96
                      if idx == -1:
                          revert with 0, 17
                      idx = idx + 1
                      s = sha3(mem[_654 + 32 len mem[_654]])
                      continue 
                  mem[mem[64] + 32] = s + sha3(mem[128 len 20])
                  mem[mem[64] + 64] = _631
                  _658 = mem[64]
                  mem[mem[64]] = 64
                  mem[64] = mem[64] + 96
                  if idx == -1:
                      revert with 0, 17
                  idx = idx + 1
                  s = sha3(mem[_658 + 32 len mem[_658]])
                  continue 
              if s != _merkleRoot:
                  revert with 0, 'BASE_COLLECTION/CANNOT_MINT_PRESALE'
              if _presalePrice and count > -1 / _presalePrice:
                  revert with 0, 17
              if _presalePrice * count > call.value:
                  revert with 0, 'BASE_COLLECTION/INSUFFICIENT_ETH_AMOUNT'
              mem[0] = caller
              if stor28[caller] > !count:
                  revert with 0, 17
              stor28[caller] += count
              _743 = mem[64]
              mem[64] = mem[64] + 32
              mem[_743] = 0
              if not caller:
                  revert with 0, 'ERC721A: mint to the zero address'
              if stor1 > stor1:
                  revert with 0, 'ERC721A: token already minted'
              if count > 2500:
                  revert with 0, 'ERC721A: quantity to mint too high'
              mem[0] = caller
              mem[32] = 5
              _786 = mem[64]
              mem[64] = mem[64] + 64
              mem[_786] = balanceOf[caller].field_0
              mem[_786 + 32] = balanceOf[caller].field_128
              _787 = mem[64]
              mem[64] = mem[64] + 64
              if balanceOf[caller].field_0 > -uint128(count) + LOCK8605463013():
                  revert with 0, 17
              mem[_787] = uint128(uint128(count) + balanceOf[caller].field_0)
              if balanceOf[caller].field_128 > -uint128(count) + LOCK8605463013():
                  revert with 0, 17
              mem[_787 + 32] = uint128(uint128(count) + balanceOf[caller].field_128)
              mem[0] = caller
              mem[32] = 5
              balanceOf[caller].field_0 = uint128(uint128(count) + balanceOf[caller].field_0)
              balanceOf[caller].field_128 = uint128(uint128(count) + balanceOf[caller].field_128)
              _854 = mem[64]
              mem[64] = mem[64] + 64
              mem[_854] = caller
              mem[_854 + 32] = uint64(block.timestamp)
              mem[0] = stor1
              mem[32] = 4
              stor4[stor1].field_0 = caller
              stor4[stor1].field_160 = uint64(block.timestamp)
              idx = 0
              s = stor1
              while idx < count:
                  log Transfer(
                        address from=0,
                        address to=caller,
                        uint256 value=s)
                  if not ext_code.size(caller):
                      if s == -1:
                          revert with 0, 17
                      if idx == -1:
                          revert with 0, 17
                      idx = idx + 1
                      s = s + 1
                      continue 
                  mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                  mem[mem[64] + 4] = caller
                  mem[mem[64] + 36] = 0
                  mem[mem[64] + 68] = s
                  mem[mem[64] + 100] = 128
                  mem[mem[64] + 132] = 0
                  idx = 0
                  while idx < 0:
                      mem[idx + mem[64] + 164] = mem[idx + _743 + 32]
                      idx = idx + 32
                      continue 
                  require ext_code.size(caller)
                  call caller.onERC721Received(address , address , uint256 , bytes ) with:
                       gas gas_remaining wei
                      args caller, 0, s, 128, 0
                  mem[mem[64]] = ext_call.return_data[0]
                  if not ext_call.success:
                      if not return_data.size:
                          if not mem[96]:
                              revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                          revert with memory
                            from 128
                             len mem[96]
                      if not return_data.size:
                          revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                      revert with ext_call.return_data[0 len return_data.size]
                  _1449 = mem[64]
                  mem[64] = mem[64] + ceil32(return_data.size)
                  require return_data.size >=′ 32
                  require mem[_1449] == Mask(32, 224, mem[_1449])
                  if 0x150b7a0200000000000000000000000000000000000000000000000000000000 == Mask(32, 224, mem[_1449]):
                  ...  # Decompilation aborted, sorry: ("decompilation didn't finish",)
          else:
              if _preSaleTime >= block.timestamp:
                  revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'BASE_COLLECTION/CANNOT_MINT_PRESALE'
              if block.timestamp >= _publicSaleTime:
                  revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'BASE_COLLECTION/CANNOT_MINT_PRESALE'
              mem[128] = caller
              mem[96] = 20
              mem[64] = (32 * merkleProof.length) + 180
              mem[148] = merkleProof.length
              mem[180 len 32 * merkleProof.length] = call.data[merkleProof + 36 len 32 * merkleProof.length]
              mem[(32 * merkleProof.length) + 180] = 0
              idx = 0
              s = 0
              while idx < merkleProof.length:
                  if idx >= mem[148]:
                      revert with 0, 50
                  _632 = mem[(32 * idx) + 180]
                  if s + sha3(mem[128 len 20]) > mem[(32 * idx) + 180]:
                      mem[mem[64] + 32] = mem[(32 * idx) + 180]
                      mem[mem[64] + 64] = s + sha3(mem[128 len 20])
                      _662 = mem[64]
                      mem[mem[64]] = 64
                      mem[64] = mem[64] + 96
                      if idx == -1:
                          revert with 0, 17
                      idx = idx + 1
                      s = sha3(mem[_662 + 32 len mem[_662]])
                      continue 
                  mem[mem[64] + 32] = s + sha3(mem[128 len 20])
                  mem[mem[64] + 64] = _632
                  _666 = mem[64]
                  mem[mem[64]] = 64
                  mem[64] = mem[64] + 96
                  if idx == -1:
                      revert with 0, 17
                  idx = idx + 1
                  s = sha3(mem[_666 + 32 len mem[_666]])
                  continue 
              if s != _merkleRoot:
                  revert with 0, 'BASE_COLLECTION/CANNOT_MINT_PRESALE'
              if _presalePrice and count > -1 / _presalePrice:
                  revert with 0, 17
              if _presalePrice * count > call.value:
                  revert with 0, 'BASE_COLLECTION/INSUFFICIENT_ETH_AMOUNT'
              mem[0] = caller
              if stor28[caller] > !count:
                  revert with 0, 17
              stor28[caller] += count
              _744 = mem[64]
              mem[64] = mem[64] + 32
              mem[_744] = 0
              if not caller:
                  revert with 0, 'ERC721A: mint to the zero address'
              if stor1 > stor1:
                  revert with 0, 'ERC721A: token already minted'
              if count > 2500:
                  revert with 0, 'ERC721A: quantity to mint too high'
              mem[0] = caller
              mem[32] = 5
              _792 = mem[64]
              mem[64] = mem[64] + 64
              mem[_792] = balanceOf[caller].field_0
              mem[_792 + 32] = balanceOf[caller].field_128
              _793 = mem[64]
              mem[64] = mem[64] + 64
              if balanceOf[caller].field_0 > -uint128(count) + LOCK8605463013():
                  revert with 0, 17
              mem[_793] = uint128(uint128(count) + balanceOf[caller].field_0)
              if balanceOf[caller].field_128 > -uint128(count) + LOCK8605463013():
                  revert with 0, 17
              mem[_793 + 32] = uint128(uint128(count) + balanceOf[caller].field_128)
              mem[0] = caller
              mem[32] = 5
              balanceOf[caller].field_0 = uint128(uint128(count) + balanceOf[caller].field_0)
              balanceOf[caller].field_128 = uint128(uint128(count) + balanceOf[caller].field_128)
              _861 = mem[64]
              mem[64] = mem[64] + 64
              mem[_861] = caller
              mem[_861 + 32] = uint64(block.timestamp)
              mem[0] = stor1
              mem[32] = 4
              stor4[stor1].field_0 = caller
              stor4[stor1].field_160 = uint64(block.timestamp)
              idx = 0
              s = stor1
              while idx < count:
                  log Transfer(
                        address from=0,
                        address to=caller,
                        uint256 value=s)
                  if not ext_code.size(caller):
                      if s == -1:
                          revert with 0, 17
                      if idx == -1:
                          revert with 0, 17
                      idx = idx + 1
                      s = s + 1
                      continue 
                  mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                  mem[mem[64] + 4] = caller
                  mem[mem[64] + 36] = 0
                  mem[mem[64] + 68] = s
                  mem[mem[64] + 100] = 128
                  mem[mem[64] + 132] = 0
                  idx = 0
                  while idx < 0:
                      mem[idx + mem[64] + 164] = mem[idx + _744 + 32]
                      idx = idx + 32
                      continue 
                  require ext_code.size(caller)
                  call caller.onERC721Received(address , address , uint256 , bytes ) with:
                       gas gas_remaining wei
                      args caller, 0, s, 128, 0
                  mem[mem[64]] = ext_call.return_data[0]
                  if not ext_call.success:
                      if not return_data.size:
                          if not mem[96]:
                              revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                          revert with memory
                            from 128
                             len mem[96]
                      if not return_data.size:
                          revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                      revert with ext_call.return_data[0 len return_data.size]
                  _1451 = mem[64]
                  mem[64] = mem[64] + ceil32(return_data.size)
                  require return_data.size >=′ 32
                  require mem[_1451] == Mask(32, 224, mem[_1451])
                  if 0x150b7a0200000000000000000000000000000000000000000000000000000000 == Mask(32, 224, mem[_1451]):
                  ...  # Decompilation aborted, sorry: ("decompilation didn't finish",)
  else:
      if count > _maxTxPerAddress:
          revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'BASE_COLLECTION/EXCEEDS_MAX_PER_TRANSACTION'
      mem[0] = caller
      mem[32] = 28
      if stor28[caller] > !count:
          revert with 0, 17
      if not _presaleMaxPerAddress:
          if not _preSaleTime:
              mem[128] = caller
              mem[96] = 20
              mem[64] = (32 * merkleProof.length) + 180
              mem[148] = merkleProof.length
              mem[180 len 32 * merkleProof.length] = call.data[merkleProof + 36 len 32 * merkleProof.length]
              mem[(32 * merkleProof.length) + 180] = 0
              idx = 0
              s = 0
              while idx < merkleProof.length:
                  if idx >= mem[148]:
                      revert with 0, 50
                  _633 = mem[(32 * idx) + 180]
                  if s + sha3(mem[128 len 20]) > mem[(32 * idx) + 180]:
                      mem[mem[64] + 32] = mem[(32 * idx) + 180]
                      mem[mem[64] + 64] = s + sha3(mem[128 len 20])
                      _670 = mem[64]
                      mem[mem[64]] = 64
                      mem[64] = mem[64] + 96
                      if idx == -1:
                          revert with 0, 17
                      idx = idx + 1
                      s = sha3(mem[_670 + 32 len mem[_670]])
                      continue 
                  mem[mem[64] + 32] = s + sha3(mem[128 len 20])
                  mem[mem[64] + 64] = _633
                  _674 = mem[64]
                  mem[mem[64]] = 64
                  mem[64] = mem[64] + 96
                  if idx == -1:
                      revert with 0, 17
                  idx = idx + 1
                  s = sha3(mem[_674 + 32 len mem[_674]])
                  continue 
              if s != _merkleRoot:
                  revert with 0, 'BASE_COLLECTION/CANNOT_MINT_PRESALE'
              if _presalePrice and count > -1 / _presalePrice:
                  revert with 0, 17
              if _presalePrice * count > call.value:
                  revert with 0, 'BASE_COLLECTION/INSUFFICIENT_ETH_AMOUNT'
              mem[0] = caller
              if stor28[caller] > !count:
                  revert with 0, 17
              stor28[caller] += count
              _745 = mem[64]
              mem[64] = mem[64] + 32
              mem[_745] = 0
              if not caller:
                  revert with 0, 'ERC721A: mint to the zero address'
              if stor1 > stor1:
                  revert with 0, 'ERC721A: token already minted'
              if count > 2500:
                  revert with 0, 'ERC721A: quantity to mint too high'
              mem[0] = caller
              mem[32] = 5
              _798 = mem[64]
              mem[64] = mem[64] + 64
              mem[_798] = balanceOf[caller].field_0
              mem[_798 + 32] = balanceOf[caller].field_128
              _799 = mem[64]
              mem[64] = mem[64] + 64
              if balanceOf[caller].field_0 > -uint128(count) + LOCK8605463013():
                  revert with 0, 17
              mem[_799] = uint128(uint128(count) + balanceOf[caller].field_0)
              if balanceOf[caller].field_128 > -uint128(count) + LOCK8605463013():
                  revert with 0, 17
              mem[_799 + 32] = uint128(uint128(count) + balanceOf[caller].field_128)
              mem[0] = caller
              mem[32] = 5
              balanceOf[caller].field_0 = uint128(uint128(count) + balanceOf[caller].field_0)
              balanceOf[caller].field_128 = uint128(uint128(count) + balanceOf[caller].field_128)
              _868 = mem[64]
              mem[64] = mem[64] + 64
              mem[_868] = caller
              mem[_868 + 32] = uint64(block.timestamp)
              mem[0] = stor1
              mem[32] = 4
              stor4[stor1].field_0 = caller
              stor4[stor1].field_160 = uint64(block.timestamp)
              idx = 0
              s = stor1
              while idx < count:
                  log Transfer(
                        address from=0,
                        address to=caller,
                        uint256 value=s)
                  if not ext_code.size(caller):
                      if s == -1:
                          revert with 0, 17
                      if idx == -1:
                          revert with 0, 17
                      idx = idx + 1
                      s = s + 1
                      continue 
                  mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                  mem[mem[64] + 4] = caller
                  mem[mem[64] + 36] = 0
                  mem[mem[64] + 68] = s
                  mem[mem[64] + 100] = 128
                  mem[mem[64] + 132] = 0
                  idx = 0
                  while idx < 0:
                      mem[idx + mem[64] + 164] = mem[idx + _745 + 32]
                      idx = idx + 32
                      continue 
                  require ext_code.size(caller)
                  call caller.onERC721Received(address , address , uint256 , bytes ) with:
                       gas gas_remaining wei
                      args caller, 0, s, 128, 0
                  mem[mem[64]] = ext_call.return_data[0]
                  if not ext_call.success:
                      if not return_data.size:
                          if not mem[96]:
                              revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                          revert with memory
                            from 128
                             len mem[96]
                      if not return_data.size:
                          revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                      revert with ext_call.return_data[0 len return_data.size]
                  _1453 = mem[64]
                  mem[64] = mem[64] + ceil32(return_data.size)
                  require return_data.size >=′ 32
                  require mem[_1453] == Mask(32, 224, mem[_1453])
                  if 0x150b7a0200000000000000000000000000000000000000000000000000000000 == Mask(32, 224, mem[_1453]):
                  ...  # Decompilation aborted, sorry: ("decompilation didn't finish",)
          else:
              if _preSaleTime >= block.timestamp:
                  revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'BASE_COLLECTION/CANNOT_MINT_PRESALE'
              if block.timestamp >= _publicSaleTime:
                  revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'BASE_COLLECTION/CANNOT_MINT_PRESALE'
              mem[128] = caller
              mem[96] = 20
              mem[64] = (32 * merkleProof.length) + 180
              mem[148] = merkleProof.length
              mem[180 len 32 * merkleProof.length] = call.data[merkleProof + 36 len 32 * merkleProof.length]
              mem[(32 * merkleProof.length) + 180] = 0
              idx = 0
              s = 0
              while idx < merkleProof.length:
                  if idx >= mem[148]:
                      revert with 0, 50
                  _634 = mem[(32 * idx) + 180]
                  if s + sha3(mem[128 len 20]) > mem[(32 * idx) + 180]:
                      mem[mem[64] + 32] = mem[(32 * idx) + 180]
                      mem[mem[64] + 64] = s + sha3(mem[128 len 20])
                      _678 = mem[64]
                      mem[mem[64]] = 64
                      mem[64] = mem[64] + 96
                      if idx == -1:
                          revert with 0, 17
                      idx = idx + 1
                      s = sha3(mem[_678 + 32 len mem[_678]])
                      continue 
                  mem[mem[64] + 32] = s + sha3(mem[128 len 20])
                  mem[mem[64] + 64] = _634
                  _682 = mem[64]
                  mem[mem[64]] = 64
                  mem[64] = mem[64] + 96
                  if idx == -1:
                      revert with 0, 17
                  idx = idx + 1
                  s = sha3(mem[_682 + 32 len mem[_682]])
                  continue 
              if s != _merkleRoot:
                  revert with 0, 'BASE_COLLECTION/CANNOT_MINT_PRESALE'
              if _presalePrice and count > -1 / _presalePrice:
                  revert with 0, 17
              if _presalePrice * count > call.value:
                  revert with 0, 'BASE_COLLECTION/INSUFFICIENT_ETH_AMOUNT'
              mem[0] = caller
              if stor28[caller] > !count:
                  revert with 0, 17
              stor28[caller] += count
              _746 = mem[64]
              mem[64] = mem[64] + 32
              mem[_746] = 0
              if not caller:
                  revert with 0, 'ERC721A: mint to the zero address'
              if stor1 > stor1:
                  revert with 0, 'ERC721A: token already minted'
              if count > 2500:
                  revert with 0, 'ERC721A: quantity to mint too high'
              mem[0] = caller
              mem[32] = 5
              _804 = mem[64]
              mem[64] = mem[64] + 64
              mem[_804] = balanceOf[caller].field_0
              mem[_804 + 32] = balanceOf[caller].field_128
              _805 = mem[64]
              mem[64] = mem[64] + 64
              if balanceOf[caller].field_0 > -uint128(count) + LOCK8605463013():
                  revert with 0, 17
              mem[_805] = uint128(uint128(count) + balanceOf[caller].field_0)
              if balanceOf[caller].field_128 > -uint128(count) + LOCK8605463013():
                  revert with 0, 17
              mem[_805 + 32] = uint128(uint128(count) + balanceOf[caller].field_128)
              mem[0] = caller
              mem[32] = 5
              balanceOf[caller].field_0 = uint128(uint128(count) + balanceOf[caller].field_0)
              balanceOf[caller].field_128 = uint128(uint128(count) + balanceOf[caller].field_128)
              _875 = mem[64]
              mem[64] = mem[64] + 64
              mem[_875] = caller
              mem[_875 + 32] = uint64(block.timestamp)
              mem[0] = stor1
              mem[32] = 4
              stor4[stor1].field_0 = caller
              stor4[stor1].field_160 = uint64(block.timestamp)
              idx = 0
              s = stor1
              while idx < count:
                  log Transfer(
                        address from=0,
                        address to=caller,
                        uint256 value=s)
                  if not ext_code.size(caller):
                      if s == -1:
                          revert with 0, 17
                      if idx == -1:
                          revert with 0, 17
                      idx = idx + 1
                      s = s + 1
                      continue 
                  mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                  mem[mem[64] + 4] = caller
                  mem[mem[64] + 36] = 0
                  mem[mem[64] + 68] = s
                  mem[mem[64] + 100] = 128
                  mem[mem[64] + 132] = 0
                  idx = 0
                  while idx < 0:
                      mem[idx + mem[64] + 164] = mem[idx + _746 + 32]
                      idx = idx + 32
                      continue 
                  require ext_code.size(caller)
                  call caller.onERC721Received(address , address , uint256 , bytes ) with:
                       gas gas_remaining wei
                      args caller, 0, s, 128, 0
                  mem[mem[64]] = ext_call.return_data[0]
                  if not ext_call.success:
                      if not return_data.size:
                          if not mem[96]:
                              revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                          revert with memory
                            from 128
                             len mem[96]
                      if not return_data.size:
                          revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                      revert with ext_call.return_data[0 len return_data.size]
                  _1455 = mem[64]
                  mem[64] = mem[64] + ceil32(return_data.size)
                  require return_data.size >=′ 32
                  require mem[_1455] == Mask(32, 224, mem[_1455])
                  if 0x150b7a0200000000000000000000000000000000000000000000000000000000 == Mask(32, 224, mem[_1455]):
                  ...  # Decompilation aborted, sorry: ("decompilation didn't finish",)
      else:
          if stor28[caller] + count > _presaleMaxPerAddress:
              revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'BASE_COLLECTION/EXCEEDS_INDIVIDUAL_SUPPLY'
          if not _preSaleTime:
              mem[128] = caller
              mem[96] = 20
              mem[64] = (32 * merkleProof.length) + 180
              mem[148] = merkleProof.length
              mem[180 len 32 * merkleProof.length] = call.data[merkleProof + 36 len 32 * merkleProof.length]
              mem[(32 * merkleProof.length) + 180] = 0
              idx = 0
              s = 0
              while idx < merkleProof.length:
                  if idx >= mem[148]:
                      revert with 0, 50
                  _635 = mem[(32 * idx) + 180]
                  if s + sha3(mem[128 len 20]) > mem[(32 * idx) + 180]:
                      mem[mem[64] + 32] = mem[(32 * idx) + 180]
                      mem[mem[64] + 64] = s + sha3(mem[128 len 20])
                      _686 = mem[64]
                      mem[mem[64]] = 64
                      mem[64] = mem[64] + 96
                      if idx == -1:
                          revert with 0, 17
                      idx = idx + 1
                      s = sha3(mem[_686 + 32 len mem[_686]])
                      continue 
                  mem[mem[64] + 32] = s + sha3(mem[128 len 20])
                  mem[mem[64] + 64] = _635
                  _690 = mem[64]
                  mem[mem[64]] = 64
                  mem[64] = mem[64] + 96
                  if idx == -1:
                      revert with 0, 17
                  idx = idx + 1
                  s = sha3(mem[_690 + 32 len mem[_690]])
                  continue 
              if s != _merkleRoot:
                  revert with 0, 'BASE_COLLECTION/CANNOT_MINT_PRESALE'
              if _presalePrice and count > -1 / _presalePrice:
                  revert with 0, 17
              if _presalePrice * count > call.value:
                  revert with 0, 'BASE_COLLECTION/INSUFFICIENT_ETH_AMOUNT'
              mem[0] = caller
              if stor28[caller] > !count:
                  revert with 0, 17
              stor28[caller] += count
              _747 = mem[64]
              mem[64] = mem[64] + 32
              mem[_747] = 0
              if not caller:
                  revert with 0, 'ERC721A: mint to the zero address'
              if stor1 > stor1:
                  revert with 0, 'ERC721A: token already minted'
              if count > 2500:
                  revert with 0, 'ERC721A: quantity to mint too high'
              mem[0] = caller
              mem[32] = 5
              _810 = mem[64]
              mem[64] = mem[64] + 64
              mem[_810] = balanceOf[caller].field_0
              mem[_810 + 32] = balanceOf[caller].field_128
              _811 = mem[64]
              mem[64] = mem[64] + 64
              if balanceOf[caller].field_0 > -uint128(count) + LOCK8605463013():
                  revert with 0, 17
              mem[_811] = uint128(uint128(count) + balanceOf[caller].field_0)
              if balanceOf[caller].field_128 > -uint128(count) + LOCK8605463013():
                  revert with 0, 17
              mem[_811 + 32] = uint128(uint128(count) + balanceOf[caller].field_128)
              mem[0] = caller
              mem[32] = 5
              balanceOf[caller].field_0 = uint128(uint128(count) + balanceOf[caller].field_0)
              balanceOf[caller].field_128 = uint128(uint128(count) + balanceOf[caller].field_128)
              _882 = mem[64]
              mem[64] = mem[64] + 64
              mem[_882] = caller
              mem[_882 + 32] = uint64(block.timestamp)
              mem[0] = stor1
              mem[32] = 4
              stor4[stor1].field_0 = caller
              stor4[stor1].field_160 = uint64(block.timestamp)
              idx = 0
              s = stor1
              while idx < count:
                  log Transfer(
                        address from=0,
                        address to=caller,
                        uint256 value=s)
                  if not ext_code.size(caller):
                      if s == -1:
                          revert with 0, 17
                      if idx == -1:
                          revert with 0, 17
                      idx = idx + 1
                      s = s + 1
                      continue 
                  mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                  mem[mem[64] + 4] = caller
                  mem[mem[64] + 36] = 0
                  mem[mem[64] + 68] = s
                  mem[mem[64] + 100] = 128
                  mem[mem[64] + 132] = 0
                  idx = 0
                  while idx < 0:
                      mem[idx + mem[64] + 164] = mem[idx + _747 + 32]
                      idx = idx + 32
                      continue 
                  require ext_code.size(caller)
                  call caller.onERC721Received(address , address , uint256 , bytes ) with:
                       gas gas_remaining wei
                      args caller, 0, s, 128, 0
                  mem[mem[64]] = ext_call.return_data[0]
                  if not ext_call.success:
                      if not return_data.size:
                          if not mem[96]:
                              revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                          revert with memory
                            from 128
                             len mem[96]
                      if not return_data.size:
                          revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                      revert with ext_call.return_data[0 len return_data.size]
                  _1457 = mem[64]
                  mem[64] = mem[64] + ceil32(return_data.size)
                  require return_data.size >=′ 32
                  require mem[_1457] == Mask(32, 224, mem[_1457])
                  if 0x150b7a0200000000000000000000000000000000000000000000000000000000 == Mask(32, 224, mem[_1457]):
                  ...  # Decompilation aborted, sorry: ("decompilation didn't finish",)
          else:
              if _preSaleTime >= block.timestamp:
                  revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'BASE_COLLECTION/CANNOT_MINT_PRESALE'
              if block.timestamp >= _publicSaleTime:
                  revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'BASE_COLLECTION/CANNOT_MINT_PRESALE'
              mem[128] = caller
              mem[96] = 20
              mem[64] = (32 * merkleProof.length) + 180
              mem[148] = merkleProof.length
              mem[180 len 32 * merkleProof.length] = call.data[merkleProof + 36 len 32 * merkleProof.length]
              mem[(32 * merkleProof.length) + 180] = 0
              idx = 0
              s = 0
              while idx < merkleProof.length:
                  if idx >= mem[148]:
                      revert with 0, 50
                  _636 = mem[(32 * idx) + 180]
                  if s + sha3(mem[128 len 20]) > mem[(32 * idx) + 180]:
                      mem[mem[64] + 32] = mem[(32 * idx) + 180]
                      mem[mem[64] + 64] = s + sha3(mem[128 len 20])
                      _694 = mem[64]
                      mem[mem[64]] = 64
                      mem[64] = mem[64] + 96
                      if idx == -1:
                          revert with 0, 17
                      idx = idx + 1
                      s = sha3(mem[_694 + 32 len mem[_694]])
                      continue 
                  mem[mem[64] + 32] = s + sha3(mem[128 len 20])
                  mem[mem[64] + 64] = _636
                  _698 = mem[64]
                  mem[mem[64]] = 64
                  mem[64] = mem[64] + 96
                  if idx == -1:
                      revert with 0, 17
                  idx = idx + 1
                  s = sha3(mem[_698 + 32 len mem[_698]])
                  continue 
              if s != _merkleRoot:
                  revert with 0, 'BASE_COLLECTION/CANNOT_MINT_PRESALE'
              if _presalePrice and count > -1 / _presalePrice:
                  revert with 0, 17
              if _presalePrice * count > call.value:
                  revert with 0, 'BASE_COLLECTION/INSUFFICIENT_ETH_AMOUNT'
              mem[0] = caller
              if stor28[caller] > !count:
                  revert with 0, 17
              stor28[caller] += count
              _748 = mem[64]
              mem[64] = mem[64] + 32
              mem[_748] = 0
              if not caller:
                  revert with 0, 'ERC721A: mint to the zero address'
              if stor1 > stor1:
                  revert with 0, 'ERC721A: token already minted'
              if count > 2500:
                  revert with 0, 'ERC721A: quantity to mint too high'
              mem[0] = caller
              mem[32] = 5
              _816 = mem[64]
              mem[64] = mem[64] + 64
              mem[_816] = balanceOf[caller].field_0
              mem[_816 + 32] = balanceOf[caller].field_128
              _817 = mem[64]
              mem[64] = mem[64] + 64
              if balanceOf[caller].field_0 > -uint128(count) + LOCK8605463013():
                  revert with 0, 17
              mem[_817] = uint128(uint128(count) + balanceOf[caller].field_0)
              if balanceOf[caller].field_128 > -uint128(count) + LOCK8605463013():
                  revert with 0, 17
              mem[_817 + 32] = uint128(uint128(count) + balanceOf[caller].field_128)
              mem[0] = caller
              mem[32] = 5
              balanceOf[caller].field_0 = uint128(uint128(count) + balanceOf[caller].field_0)
              balanceOf[caller].field_128 = uint128(uint128(count) + balanceOf[caller].field_128)
              _889 = mem[64]
              mem[64] = mem[64] + 64
              mem[_889] = caller
              mem[_889 + 32] = uint64(block.timestamp)
              mem[0] = stor1
              mem[32] = 4
              stor4[stor1].field_0 = caller
              stor4[stor1].field_160 = uint64(block.timestamp)
              idx = 0
              s = stor1
              while idx < count:
                  log Transfer(
                        address from=0,
                        address to=caller,
                        uint256 value=s)
                  if not ext_code.size(caller):
                      if s == -1:
                          revert with 0, 17
                      if idx == -1:
                          revert with 0, 17
                      idx = idx + 1
                      s = s + 1
                      continue 
                  mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                  mem[mem[64] + 4] = caller
                  mem[mem[64] + 36] = 0
                  mem[mem[64] + 68] = s
                  mem[mem[64] + 100] = 128
                  mem[mem[64] + 132] = 0
                  idx = 0
                  while idx < 0:
                      mem[idx + mem[64] + 164] = mem[idx + _748 + 32]
                      idx = idx + 32
                      continue 
                  require ext_code.size(caller)
                  call caller.onERC721Received(address , address , uint256 , bytes ) with:
                       gas gas_remaining wei
                      args caller, 0, s, 128, 0
                  mem[mem[64]] = ext_call.return_data[0]
                  if not ext_call.success:
                      if not return_data.size:
                          if not mem[96]:
                              revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                          revert with memory
                            from 128
                             len mem[96]
                      if not return_data.size:
                          revert with 0, 'ERC721A: transfer to non ERC721Receiver implementer'
                      revert with ext_call.return_data[0 len return_data.size]
                  _1459 = mem[64]
                  mem[64] = mem[64] + ceil32(return_data.size)
                  require return_data.size >=′ 32
                  require mem[_1459] == Mask(32, 224, mem[_1459])
                  if 0x150b7a0200000000000000000000000000000000000000000000000000000000 == Mask(32, 224, mem[_1459]):
                  ...  # Decompilation aborted, sorry: ("decompilation didn't finish",)
  stor1 = s
  log EarlyPurchase(
        address addr=caller,
        uint256 atPrice=_presalePrice,
        uint256 count=count)

def safeTransferFrom(address from, address to, uint256 tokenId): # not payable
  require calldata.size - 4 >=′ 96
  require from == from
  require to == to
  mem[96] = 0
  mem[64] = 192
  mem[128] = 0
  mem[160] = 0
  if stor1 <= tokenId:
      revert with 0, 'ERC721A: owner query for nonexistent token'
  if tokenId < 2500:
      idx = tokenId
      while idx >= 0:
          mem[0] = idx
          mem[32] = 4
          _753 = mem[64]
          mem[64] = mem[64] + 64
          mem[_753] = stor4[idx].field_0
          mem[_753 + 32] = stor4[idx].field_160
          if not stor4[idx].field_0:
              if not idx:
                  revert with 0, 17
              idx = idx - 1
              continue 
          if caller == stor4[idx].field_0:
              if stor4[idx].field_0 != from:
                  revert with 0, 'ERC721A: transfer from incorrect owner'
              if not to:
                  revert with 0, 'ERC721A: transfer to the zero address'
              approved[tokenId] = 0
              log Approval(
                    address owner=stor4[idx].field_0,
                    address spender=0,
                    uint256 value=tokenId)
              if balanceOf[address(from)].field_0 < 1:
                  revert with 0, 17
              balanceOf[address(from)].field_0 = uint128(balanceOf[address(from)].field_0 - 1)
              mem[0] = to
              mem[32] = 5
              if balanceOf[address(to)].field_0 > LOCK8605463013():
                  revert with 0, 17
              balanceOf[address(to)].field_0 = uint128(balanceOf[address(to)].field_0 + 1)
              _825 = mem[64]
              mem[64] = mem[64] + 64
              mem[_825] = to
              mem[_825 + 32] = uint64(block.timestamp)
              stor4[tokenId].field_0 = to
              stor4[tokenId].field_160 = uint64(block.timestamp)
              if 1 > !tokenId:
                  revert with 0, 17
              mem[0] = tokenId + 1
              mem[32] = 4
              if stor4[tokenId + 1].field_0:
                  log Transfer(
                        address from=from,
                        address to=to,
                        uint256 value=tokenId)
                  if not ext_code.size(to):
                      stop
                  mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                  mem[mem[64] + 4] = caller
                  mem[mem[64] + 36] = from
                  mem[mem[64] + 68] = tokenId
                  mem[mem[64] + 100] = 128
                  mem[mem[64] + 132] = mem[96]
                  idx = 0
                  while idx < mem[96]:
                      mem[idx + mem[64] + 164] = mem[idx + 128]
                      idx = idx + 32
                      continue 
                  if ceil32(mem[96]) <= mem[96]:
                      require ext_code.size(to)
                      call to.onERC721Received(address , address , uint256 , bytes ) with:
                           gas gas_remaining wei
                          args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                      mem[mem[64]] = ext_call.return_data[0]
                      if not ext_call.success:
                          if return_data.size:
                      else:
                          _1551 = mem[64]
                          mem[64] = mem[64] + ceil32(return_data.size)
                          require return_data.size >=′ 32
                  else:
                      mem[mem[96] + mem[64] + 164] = 0
                      require ext_code.size(to)
                      call to.onERC721Received(address , address , uint256 , bytes ) with:
                           gas gas_remaining wei
                          args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                      mem[mem[64]] = ext_call.return_data[0]
                      if not ext_call.success:
                          if return_data.size:
                      else:
                          _1552 = mem[64]
                          mem[64] = mem[64] + ceil32(return_data.size)
                          require return_data.size >=′ 32
              else:
                  if stor1 <= tokenId + 1:
                      log Transfer(
                            address from=from,
                            address to=to,
                            uint256 value=tokenId)
                      if not ext_code.size(to):
                          stop
                      mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                      mem[mem[64] + 4] = caller
                      mem[mem[64] + 36] = from
                      mem[mem[64] + 68] = tokenId
                      mem[mem[64] + 100] = 128
                      mem[mem[64] + 132] = mem[96]
                      idx = 0
                      while idx < mem[96]:
                          mem[idx + mem[64] + 164] = mem[idx + 128]
                          idx = idx + 32
                          continue 
                      if ceil32(mem[96]) <= mem[96]:
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if return_data.size:
                          else:
                              _1553 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                      else:
                          mem[mem[96] + mem[64] + 164] = 0
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if return_data.size:
                          else:
                              _1554 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                  else:
                      _861 = mem[64]
                      mem[64] = mem[64] + 64
                      mem[_861] = stor4[idx].field_0
                      mem[_861 + 32] = stor4[idx].field_160
                      mem[0] = tokenId + 1
                      mem[32] = 4
                      stor4[tokenId + 1].field_0 = stor4[idx].field_0
                      stor4[tokenId + 1].field_160 = stor4[idx].field_160
                      log Transfer(
                            address from=from,
                            address to=to,
                            uint256 value=tokenId)
                      if not ext_code.size(to):
                          stop
                      mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                      mem[mem[64] + 4] = caller
                      mem[mem[64] + 36] = from
                      mem[mem[64] + 68] = tokenId
                      mem[mem[64] + 100] = 128
                      mem[mem[64] + 132] = mem[96]
                      idx = 0
                      while idx < mem[96]:
                          mem[idx + mem[64] + 164] = mem[idx + 128]
                          idx = idx + 32
                          continue 
                      if ceil32(mem[96]) <= mem[96]:
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if return_data.size:
                          else:
                              _1555 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                      else:
                          mem[mem[96] + mem[64] + 164] = 0
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if return_data.size:
                          else:
                              _1556 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
          else:
              if stor1 <= tokenId:
                  revert with 0, 'ERC721A: approved query for nonexistent token'
              if approved[tokenId] == caller:
                  if stor4[idx].field_0 != from:
                      revert with 0, 'ERC721A: transfer from incorrect owner'
                  if not to:
                      revert with 0, 'ERC721A: transfer to the zero address'
                  approved[tokenId] = 0
                  log Approval(
                        address owner=stor4[idx].field_0,
                        address spender=0,
                        uint256 value=tokenId)
                  if balanceOf[address(from)].field_0 < 1:
                      revert with 0, 17
                  balanceOf[address(from)].field_0 = uint128(balanceOf[address(from)].field_0 - 1)
                  mem[0] = to
                  mem[32] = 5
                  if balanceOf[address(to)].field_0 > LOCK8605463013():
                      revert with 0, 17
                  balanceOf[address(to)].field_0 = uint128(balanceOf[address(to)].field_0 + 1)
                  _851 = mem[64]
                  mem[64] = mem[64] + 64
                  mem[_851] = to
                  mem[_851 + 32] = uint64(block.timestamp)
                  stor4[tokenId].field_0 = to
                  stor4[tokenId].field_160 = uint64(block.timestamp)
                  if 1 > !tokenId:
                      revert with 0, 17
                  mem[0] = tokenId + 1
                  mem[32] = 4
                  if stor4[tokenId + 1].field_0:
                      log Transfer(
                            address from=from,
                            address to=to,
                            uint256 value=tokenId)
                      if not ext_code.size(to):
                          stop
                      mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                      mem[mem[64] + 4] = caller
                      mem[mem[64] + 36] = from
                      mem[mem[64] + 68] = tokenId
                      mem[mem[64] + 100] = 128
                      mem[mem[64] + 132] = mem[96]
                      idx = 0
                      while idx < mem[96]:
                          mem[idx + mem[64] + 164] = mem[idx + 128]
                          idx = idx + 32
                          continue 
                      if ceil32(mem[96]) <= mem[96]:
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if return_data.size:
                          else:
                              _1557 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                      else:
                          mem[mem[96] + mem[64] + 164] = 0
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if return_data.size:
                          else:
                              _1558 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                  else:
                      if stor1 <= tokenId + 1:
                          log Transfer(
                                address from=from,
                                address to=to,
                                uint256 value=tokenId)
                          if not ext_code.size(to):
                              stop
                          mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                          mem[mem[64] + 4] = caller
                          mem[mem[64] + 36] = from
                          mem[mem[64] + 68] = tokenId
                          mem[mem[64] + 100] = 128
                          mem[mem[64] + 132] = mem[96]
                          idx = 0
                          while idx < mem[96]:
                              mem[idx + mem[64] + 164] = mem[idx + 128]
                              idx = idx + 32
                              continue 
                          if ceil32(mem[96]) <= mem[96]:
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if return_data.size:
                              else:
                                  _1559 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
                          else:
                              mem[mem[96] + mem[64] + 164] = 0
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if return_data.size:
                              else:
                                  _1560 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
                      else:
                          _904 = mem[64]
                          mem[64] = mem[64] + 64
                          mem[_904] = stor4[idx].field_0
                          mem[_904 + 32] = stor4[idx].field_160
                          mem[0] = tokenId + 1
                          mem[32] = 4
                          stor4[tokenId + 1].field_0 = stor4[idx].field_0
                          stor4[tokenId + 1].field_160 = stor4[idx].field_160
                          log Transfer(
                                address from=from,
                                address to=to,
                                uint256 value=tokenId)
                          if not ext_code.size(to):
                              stop
                          mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                          mem[mem[64] + 4] = caller
                          mem[mem[64] + 36] = from
                          mem[mem[64] + 68] = tokenId
                          mem[mem[64] + 100] = 128
                          mem[mem[64] + 132] = mem[96]
                          idx = 0
                          while idx < mem[96]:
                              mem[idx + mem[64] + 164] = mem[idx + 128]
                              idx = idx + 32
                              continue 
                          if ceil32(mem[96]) <= mem[96]:
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if return_data.size:
                              else:
                                  _1561 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
                          else:
                              mem[mem[96] + mem[64] + 164] = 0
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if return_data.size:
                              else:
                                  _1562 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
              else:
                  if not stor7[stor4[idx].field_0][caller]:
                      revert with 0, 'ERC721A: transfer caller is not owner nor approved'
                  if stor4[idx].field_0 != from:
                      revert with 0, 'ERC721A: transfer from incorrect owner'
                  if not to:
                      revert with 0, 'ERC721A: transfer to the zero address'
                  approved[tokenId] = 0
                  log Approval(
                        address owner=stor4[idx].field_0,
                        address spender=0,
                        uint256 value=tokenId)
                  if balanceOf[address(from)].field_0 < 1:
                      revert with 0, 17
                  balanceOf[address(from)].field_0 = uint128(balanceOf[address(from)].field_0 - 1)
                  mem[0] = to
                  mem[32] = 5
                  if balanceOf[address(to)].field_0 > LOCK8605463013():
                      revert with 0, 17
                  balanceOf[address(to)].field_0 = uint128(balanceOf[address(to)].field_0 + 1)
                  _877 = mem[64]
                  mem[64] = mem[64] + 64
                  mem[_877] = to
                  mem[_877 + 32] = uint64(block.timestamp)
                  stor4[tokenId].field_0 = to
                  stor4[tokenId].field_160 = uint64(block.timestamp)
                  if 1 > !tokenId:
                      revert with 0, 17
                  mem[0] = tokenId + 1
                  mem[32] = 4
                  if stor4[tokenId + 1].field_0:
                      log Transfer(
                            address from=from,
                            address to=to,
                            uint256 value=tokenId)
                      if not ext_code.size(to):
                          stop
                      mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                      mem[mem[64] + 4] = caller
                      mem[mem[64] + 36] = from
                      mem[mem[64] + 68] = tokenId
                      mem[mem[64] + 100] = 128
                      mem[mem[64] + 132] = mem[96]
                      idx = 0
                      while idx < mem[96]:
                          mem[idx + mem[64] + 164] = mem[idx + 128]
                          idx = idx + 32
                          continue 
                      if ceil32(mem[96]) <= mem[96]:
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if return_data.size:
                          else:
                              _1563 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                      else:
                          mem[mem[96] + mem[64] + 164] = 0
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if return_data.size:
                          else:
                              _1564 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                  else:
                      if stor1 <= tokenId + 1:
                          log Transfer(
                                address from=from,
                                address to=to,
                                uint256 value=tokenId)
                          if not ext_code.size(to):
                              stop
                          mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                          mem[mem[64] + 4] = caller
                          mem[mem[64] + 36] = from
                          mem[mem[64] + 68] = tokenId
                          mem[mem[64] + 100] = 128
                          mem[mem[64] + 132] = mem[96]
                          idx = 0
                          while idx < mem[96]:
                              mem[idx + mem[64] + 164] = mem[idx + 128]
                              idx = idx + 32
                              continue 
                          if ceil32(mem[96]) <= mem[96]:
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if return_data.size:
                              else:
                                  _1565 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
                          else:
                              mem[mem[96] + mem[64] + 164] = 0
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if return_data.size:
                              else:
                                  _1566 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
                      else:
                          _934 = mem[64]
                          mem[64] = mem[64] + 64
                          mem[_934] = stor4[idx].field_0
                          mem[_934 + 32] = stor4[idx].field_160
                          mem[0] = tokenId + 1
                          mem[32] = 4
                          stor4[tokenId + 1].field_0 = stor4[idx].field_0
                          stor4[tokenId + 1].field_160 = stor4[idx].field_160
                          log Transfer(
                                address from=from,
                                address to=to,
                                uint256 value=tokenId)
                          if not ext_code.size(to):
                              stop
                          mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                          mem[mem[64] + 4] = caller
                          mem[mem[64] + 36] = from
                          mem[mem[64] + 68] = tokenId
                          mem[mem[64] + 100] = 128
                          mem[mem[64] + 132] = mem[96]
                          idx = 0
                          while idx < mem[96]:
                              mem[idx + mem[64] + 164] = mem[idx + 128]
                              idx = idx + 32
                              continue 
                          if ceil32(mem[96]) <= mem[96]:
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if return_data.size:
                              else:
                                  _1567 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
                          else:
                              mem[mem[96] + mem[64] + 164] = 0
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if return_data.size:
                              else:
                                  _1568 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
          ...  # Decompilation aborted, sorry: ("decompilation didn't finish",)
  else:
      if 1 > !(tokenId - 2500):
          revert with 0, 17
      idx = tokenId
      while idx >= tokenId - 2499:
          mem[0] = idx
          mem[32] = 4
          _756 = mem[64]
          mem[64] = mem[64] + 64
          mem[_756] = stor4[idx].field_0
          mem[_756 + 32] = stor4[idx].field_160
          if not stor4[idx].field_0:
              if not idx:
                  revert with 0, 17
              idx = idx - 1
              continue 
          if caller == stor4[idx].field_0:
              if stor4[idx].field_0 != from:
                  revert with 0, 'ERC721A: transfer from incorrect owner'
              if not to:
                  revert with 0, 'ERC721A: transfer to the zero address'
              approved[tokenId] = 0
              log Approval(
                    address owner=stor4[idx].field_0,
                    address spender=0,
                    uint256 value=tokenId)
              if balanceOf[address(from)].field_0 < 1:
                  revert with 0, 17
              balanceOf[address(from)].field_0 = uint128(balanceOf[address(from)].field_0 - 1)
              mem[0] = to
              mem[32] = 5
              if balanceOf[address(to)].field_0 > LOCK8605463013():
                  revert with 0, 17
              balanceOf[address(to)].field_0 = uint128(balanceOf[address(to)].field_0 + 1)
              _832 = mem[64]
              mem[64] = mem[64] + 64
              mem[_832] = to
              mem[_832 + 32] = uint64(block.timestamp)
              stor4[tokenId].field_0 = to
              stor4[tokenId].field_160 = uint64(block.timestamp)
              if 1 > !tokenId:
                  revert with 0, 17
              mem[0] = tokenId + 1
              mem[32] = 4
              if stor4[tokenId + 1].field_0:
                  log Transfer(
                        address from=from,
                        address to=to,
                        uint256 value=tokenId)
                  if not ext_code.size(to):
                      stop
                  mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                  mem[mem[64] + 4] = caller
                  mem[mem[64] + 36] = from
                  mem[mem[64] + 68] = tokenId
                  mem[mem[64] + 100] = 128
                  mem[mem[64] + 132] = mem[96]
                  idx = 0
                  while idx < mem[96]:
                      mem[idx + mem[64] + 164] = mem[idx + 128]
                      idx = idx + 32
                      continue 
                  if ceil32(mem[96]) <= mem[96]:
                      require ext_code.size(to)
                      call to.onERC721Received(address , address , uint256 , bytes ) with:
                           gas gas_remaining wei
                          args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                      mem[mem[64]] = ext_call.return_data[0]
                      if not ext_call.success:
                          if return_data.size:
                      else:
                          _1569 = mem[64]
                          mem[64] = mem[64] + ceil32(return_data.size)
                          require return_data.size >=′ 32
                  else:
                      mem[mem[96] + mem[64] + 164] = 0
                      require ext_code.size(to)
                      call to.onERC721Received(address , address , uint256 , bytes ) with:
                           gas gas_remaining wei
                          args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                      mem[mem[64]] = ext_call.return_data[0]
                      if not ext_call.success:
                          if return_data.size:
                      else:
                          _1570 = mem[64]
                          mem[64] = mem[64] + ceil32(return_data.size)
                          require return_data.size >=′ 32
              else:
                  if stor1 <= tokenId + 1:
                      log Transfer(
                            address from=from,
                            address to=to,
                            uint256 value=tokenId)
                      if not ext_code.size(to):
                          stop
                      mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                      mem[mem[64] + 4] = caller
                      mem[mem[64] + 36] = from
                      mem[mem[64] + 68] = tokenId
                      mem[mem[64] + 100] = 128
                      mem[mem[64] + 132] = mem[96]
                      idx = 0
                      while idx < mem[96]:
                          mem[idx + mem[64] + 164] = mem[idx + 128]
                          idx = idx + 32
                          continue 
                      if ceil32(mem[96]) <= mem[96]:
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if return_data.size:
                          else:
                              _1571 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                      else:
                          mem[mem[96] + mem[64] + 164] = 0
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if return_data.size:
                          else:
                              _1572 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                  else:
                      _869 = mem[64]
                      mem[64] = mem[64] + 64
                      mem[_869] = stor4[idx].field_0
                      mem[_869 + 32] = stor4[idx].field_160
                      mem[0] = tokenId + 1
                      mem[32] = 4
                      stor4[tokenId + 1].field_0 = stor4[idx].field_0
                      stor4[tokenId + 1].field_160 = stor4[idx].field_160
                      log Transfer(
                            address from=from,
                            address to=to,
                            uint256 value=tokenId)
                      if not ext_code.size(to):
                          stop
                      mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                      mem[mem[64] + 4] = caller
                      mem[mem[64] + 36] = from
                      mem[mem[64] + 68] = tokenId
                      mem[mem[64] + 100] = 128
                      mem[mem[64] + 132] = mem[96]
                      idx = 0
                      while idx < mem[96]:
                          mem[idx + mem[64] + 164] = mem[idx + 128]
                          idx = idx + 32
                          continue 
                      if ceil32(mem[96]) <= mem[96]:
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if return_data.size:
                          else:
                              _1573 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                      else:
                          mem[mem[96] + mem[64] + 164] = 0
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if return_data.size:
                          else:
                              _1574 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
          else:
              if stor1 <= tokenId:
                  revert with 0, 'ERC721A: approved query for nonexistent token'
              if approved[tokenId] == caller:
                  if stor4[idx].field_0 != from:
                      revert with 0, 'ERC721A: transfer from incorrect owner'
                  if not to:
                      revert with 0, 'ERC721A: transfer to the zero address'
                  approved[tokenId] = 0
                  log Approval(
                        address owner=stor4[idx].field_0,
                        address spender=0,
                        uint256 value=tokenId)
                  if balanceOf[address(from)].field_0 < 1:
                      revert with 0, 17
                  balanceOf[address(from)].field_0 = uint128(balanceOf[address(from)].field_0 - 1)
                  mem[0] = to
                  mem[32] = 5
                  if balanceOf[address(to)].field_0 > LOCK8605463013():
                      revert with 0, 17
                  balanceOf[address(to)].field_0 = uint128(balanceOf[address(to)].field_0 + 1)
                  _855 = mem[64]
                  mem[64] = mem[64] + 64
                  mem[_855] = to
                  mem[_855 + 32] = uint64(block.timestamp)
                  stor4[tokenId].field_0 = to
                  stor4[tokenId].field_160 = uint64(block.timestamp)
                  if 1 > !tokenId:
                      revert with 0, 17
                  mem[0] = tokenId + 1
                  mem[32] = 4
                  if stor4[tokenId + 1].field_0:
                      log Transfer(
                            address from=from,
                            address to=to,
                            uint256 value=tokenId)
                      if not ext_code.size(to):
                          stop
                      mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                      mem[mem[64] + 4] = caller
                      mem[mem[64] + 36] = from
                      mem[mem[64] + 68] = tokenId
                      mem[mem[64] + 100] = 128
                      mem[mem[64] + 132] = mem[96]
                      idx = 0
                      while idx < mem[96]:
                          mem[idx + mem[64] + 164] = mem[idx + 128]
                          idx = idx + 32
                          continue 
                      if ceil32(mem[96]) <= mem[96]:
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if return_data.size:
                          else:
                              _1575 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                      else:
                          mem[mem[96] + mem[64] + 164] = 0
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if return_data.size:
                          else:
                              _1576 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                  else:
                      if stor1 <= tokenId + 1:
                          log Transfer(
                                address from=from,
                                address to=to,
                                uint256 value=tokenId)
                          if not ext_code.size(to):
                              stop
                          mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                          mem[mem[64] + 4] = caller
                          mem[mem[64] + 36] = from
                          mem[mem[64] + 68] = tokenId
                          mem[mem[64] + 100] = 128
                          mem[mem[64] + 132] = mem[96]
                          idx = 0
                          while idx < mem[96]:
                              mem[idx + mem[64] + 164] = mem[idx + 128]
                              idx = idx + 32
                              continue 
                          if ceil32(mem[96]) <= mem[96]:
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if return_data.size:
                              else:
                                  _1577 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
                          else:
                              mem[mem[96] + mem[64] + 164] = 0
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if return_data.size:
                              else:
                                  _1578 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
                      else:
                          _915 = mem[64]
                          mem[64] = mem[64] + 64
                          mem[_915] = stor4[idx].field_0
                          mem[_915 + 32] = stor4[idx].field_160
                          mem[0] = tokenId + 1
                          mem[32] = 4
                          stor4[tokenId + 1].field_0 = stor4[idx].field_0
                          stor4[tokenId + 1].field_160 = stor4[idx].field_160
                          log Transfer(
                                address from=from,
                                address to=to,
                                uint256 value=tokenId)
                          if not ext_code.size(to):
                              stop
                          mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                          mem[mem[64] + 4] = caller
                          mem[mem[64] + 36] = from
                          mem[mem[64] + 68] = tokenId
                          mem[mem[64] + 100] = 128
                          mem[mem[64] + 132] = mem[96]
                          idx = 0
                          while idx < mem[96]:
                              mem[idx + mem[64] + 164] = mem[idx + 128]
                              idx = idx + 32
                              continue 
                          if ceil32(mem[96]) <= mem[96]:
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if return_data.size:
                              else:
                                  _1579 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
                          else:
                              mem[mem[96] + mem[64] + 164] = 0
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if return_data.size:
                              else:
                                  _1580 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
              else:
                  if not stor7[stor4[idx].field_0][caller]:
                      revert with 0, 'ERC721A: transfer caller is not owner nor approved'
                  if stor4[idx].field_0 != from:
                      revert with 0, 'ERC721A: transfer from incorrect owner'
                  if not to:
                      revert with 0, 'ERC721A: transfer to the zero address'
                  approved[tokenId] = 0
                  log Approval(
                        address owner=stor4[idx].field_0,
                        address spender=0,
                        uint256 value=tokenId)
                  if balanceOf[address(from)].field_0 < 1:
                      revert with 0, 17
                  balanceOf[address(from)].field_0 = uint128(balanceOf[address(from)].field_0 - 1)
                  mem[0] = to
                  mem[32] = 5
                  if balanceOf[address(to)].field_0 > LOCK8605463013():
                      revert with 0, 17
                  balanceOf[address(to)].field_0 = uint128(balanceOf[address(to)].field_0 + 1)
                  _883 = mem[64]
                  mem[64] = mem[64] + 64
                  mem[_883] = to
                  mem[_883 + 32] = uint64(block.timestamp)
                  stor4[tokenId].field_0 = to
                  stor4[tokenId].field_160 = uint64(block.timestamp)
                  if 1 > !tokenId:
                      revert with 0, 17
                  mem[0] = tokenId + 1
                  mem[32] = 4
                  if stor4[tokenId + 1].field_0:
                      log Transfer(
                            address from=from,
                            address to=to,
                            uint256 value=tokenId)
                      if not ext_code.size(to):
                          stop
                      mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                      mem[mem[64] + 4] = caller
                      mem[mem[64] + 36] = from
                      mem[mem[64] + 68] = tokenId
                      mem[mem[64] + 100] = 128
                      mem[mem[64] + 132] = mem[96]
                      idx = 0
                      while idx < mem[96]:
                          mem[idx + mem[64] + 164] = mem[idx + 128]
                          idx = idx + 32
                          continue 
                      if ceil32(mem[96]) <= mem[96]:
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if return_data.size:
                          else:
                              _1581 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                      else:
                          mem[mem[96] + mem[64] + 164] = 0
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if return_data.size:
                          else:
                              _1582 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                  else:
                      if stor1 <= tokenId + 1:
                          log Transfer(
                                address from=from,
                                address to=to,
                                uint256 value=tokenId)
                          if not ext_code.size(to):
                              stop
                          mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                          mem[mem[64] + 4] = caller
                          mem[mem[64] + 36] = from
                          mem[mem[64] + 68] = tokenId
                          mem[mem[64] + 100] = 128
                          mem[mem[64] + 132] = mem[96]
                          idx = 0
                          while idx < mem[96]:
                              mem[idx + mem[64] + 164] = mem[idx + 128]
                              idx = idx + 32
                              continue 
                          if ceil32(mem[96]) <= mem[96]:
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if return_data.size:
                              else:
                                  _1583 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
                          else:
                              mem[mem[96] + mem[64] + 164] = 0
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if return_data.size:
                              else:
                                  _1584 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
                      else:
                          _945 = mem[64]
                          mem[64] = mem[64] + 64
                          mem[_945] = stor4[idx].field_0
                          mem[_945 + 32] = stor4[idx].field_160
                          mem[0] = tokenId + 1
                          mem[32] = 4
                          stor4[tokenId + 1].field_0 = stor4[idx].field_0
                          stor4[tokenId + 1].field_160 = stor4[idx].field_160
                          log Transfer(
                                address from=from,
                                address to=to,
                                uint256 value=tokenId)
                          if not ext_code.size(to):
                              stop
                          mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                          mem[mem[64] + 4] = caller
                          mem[mem[64] + 36] = from
                          mem[mem[64] + 68] = tokenId
                          mem[mem[64] + 100] = 128
                          mem[mem[64] + 132] = mem[96]
                          idx = 0
                          while idx < mem[96]:
                              mem[idx + mem[64] + 164] = mem[idx + 128]
                              idx = idx + 32
                              continue 
                          if ceil32(mem[96]) <= mem[96]:
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if return_data.size:
                              else:
                                  _1585 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
                          else:
                              mem[mem[96] + mem[64] + 164] = 0
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if return_data.size:
                              else:
                                  _1586 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
          ...  # Decompilation aborted, sorry: ("decompilation didn't finish",)
  revert with 0, 'ERC721A: unable to determine the owner of token'

def safeTransferFrom(address from, address to, uint256 tokenId, bytes _data): # not payable
  require calldata.size - 4 >=′ 128
  require from == from
  require to == to
  require _data <= LOCK8605463013()
  require calldata.size >′ _data + 35
  if _data.length > LOCK8605463013():
      revert with 0, 65
  if ceil32(ceil32(_data.length)) + 97 < 96 or ceil32(ceil32(_data.length)) + 97 > LOCK8605463013():
      revert with 0, 65
  mem[96] = _data.length
  require _data + _data.length + 36 <= calldata.size
  mem[128 len _data.length] = _data[all]
  mem[64] = ceil32(ceil32(_data.length)) + 161
  mem[ceil32(ceil32(_data.length)) + 97] = 0
  mem[ceil32(ceil32(_data.length)) + 129] = 0
  if stor1 <= tokenId:
      revert with 0, 'ERC721A: owner query for nonexistent token'
  if tokenId < 2500:
      idx = tokenId
      while idx >= 0:
          mem[0] = idx
          mem[32] = 4
          _753 = mem[64]
          mem[64] = mem[64] + 64
          mem[_753] = stor4[idx].field_0
          mem[_753 + 32] = stor4[idx].field_160
          if not stor4[idx].field_0:
              if not idx:
                  revert with 0, 17
              idx = idx - 1
              continue 
          if caller == stor4[idx].field_0:
              if stor4[idx].field_0 != from:
                  revert with 0, 'ERC721A: transfer from incorrect owner'
              if not to:
                  revert with 0, 'ERC721A: transfer to the zero address'
              approved[tokenId] = 0
              log Approval(
                    address owner=stor4[idx].field_0,
                    address spender=0,
                    uint256 value=tokenId)
              if balanceOf[address(from)].field_0 < 1:
                  revert with 0, 17
              balanceOf[address(from)].field_0 = uint128(balanceOf[address(from)].field_0 - 1)
              mem[0] = to
              mem[32] = 5
              if balanceOf[address(to)].field_0 > LOCK8605463013():
                  revert with 0, 17
              balanceOf[address(to)].field_0 = uint128(balanceOf[address(to)].field_0 + 1)
              _825 = mem[64]
              mem[64] = mem[64] + 64
              mem[_825] = to
              mem[_825 + 32] = uint64(block.timestamp)
              stor4[tokenId].field_0 = to
              stor4[tokenId].field_160 = uint64(block.timestamp)
              if 1 > !tokenId:
                  revert with 0, 17
              mem[0] = tokenId + 1
              mem[32] = 4
              if stor4[tokenId + 1].field_0:
                  log Transfer(
                        address from=from,
                        address to=to,
                        uint256 value=tokenId)
                  if not ext_code.size(to):
                      stop
                  mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                  mem[mem[64] + 4] = caller
                  mem[mem[64] + 36] = from
                  mem[mem[64] + 68] = tokenId
                  mem[mem[64] + 100] = 128
                  mem[mem[64] + 132] = mem[96]
                  idx = 0
                  while idx < mem[96]:
                      mem[idx + mem[64] + 164] = mem[idx + 128]
                      idx = idx + 32
                      continue 
                  if ceil32(mem[96]) <= mem[96]:
                      require ext_code.size(to)
                      call to.onERC721Received(address , address , uint256 , bytes ) with:
                           gas gas_remaining wei
                          args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                      mem[mem[64]] = ext_call.return_data[0]
                      if not ext_call.success:
                          if not return_data.size:
                              if mem[96]:
                                  revert with memory
                                    from 128
                                     len mem[96]
                          else:
                              if return_data.size:
                                  revert with ext_call.return_data[0 len return_data.size]
                      else:
                          _1551 = mem[64]
                          mem[64] = mem[64] + ceil32(return_data.size)
                          require return_data.size >=′ 32
                          require mem[_1551] == Mask(32, 224, mem[_1551])
                  else:
                      mem[mem[96] + mem[64] + 164] = 0
                      require ext_code.size(to)
                      call to.onERC721Received(address , address , uint256 , bytes ) with:
                           gas gas_remaining wei
                          args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                      mem[mem[64]] = ext_call.return_data[0]
                      if not ext_call.success:
                          if not return_data.size:
                              if mem[96]:
                                  revert with memory
                                    from 128
                                     len mem[96]
                          else:
                              if return_data.size:
                                  revert with ext_call.return_data[0 len return_data.size]
                      else:
                          _1552 = mem[64]
                          mem[64] = mem[64] + ceil32(return_data.size)
                          require return_data.size >=′ 32
                          require mem[_1552] == Mask(32, 224, mem[_1552])
              else:
                  if stor1 <= tokenId + 1:
                      log Transfer(
                            address from=from,
                            address to=to,
                            uint256 value=tokenId)
                      if not ext_code.size(to):
                          stop
                      mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                      mem[mem[64] + 4] = caller
                      mem[mem[64] + 36] = from
                      mem[mem[64] + 68] = tokenId
                      mem[mem[64] + 100] = 128
                      mem[mem[64] + 132] = mem[96]
                      idx = 0
                      while idx < mem[96]:
                          mem[idx + mem[64] + 164] = mem[idx + 128]
                          idx = idx + 32
                          continue 
                      if ceil32(mem[96]) <= mem[96]:
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if mem[96]:
                                      revert with memory
                                        from 128
                                         len mem[96]
                              else:
                                  if return_data.size:
                                      revert with ext_call.return_data[0 len return_data.size]
                          else:
                              _1553 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                              require mem[_1553] == Mask(32, 224, mem[_1553])
                      else:
                          mem[mem[96] + mem[64] + 164] = 0
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if mem[96]:
                                      revert with memory
                                        from 128
                                         len mem[96]
                              else:
                                  if return_data.size:
                                      revert with ext_call.return_data[0 len return_data.size]
                          else:
                              _1554 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                              require mem[_1554] == Mask(32, 224, mem[_1554])
                  else:
                      _861 = mem[64]
                      mem[64] = mem[64] + 64
                      mem[_861] = stor4[idx].field_0
                      mem[_861 + 32] = stor4[idx].field_160
                      mem[0] = tokenId + 1
                      mem[32] = 4
                      stor4[tokenId + 1].field_0 = stor4[idx].field_0
                      stor4[tokenId + 1].field_160 = stor4[idx].field_160
                      log Transfer(
                            address from=from,
                            address to=to,
                            uint256 value=tokenId)
                      if not ext_code.size(to):
                          stop
                      mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                      mem[mem[64] + 4] = caller
                      mem[mem[64] + 36] = from
                      mem[mem[64] + 68] = tokenId
                      mem[mem[64] + 100] = 128
                      mem[mem[64] + 132] = mem[96]
                      idx = 0
                      while idx < mem[96]:
                          mem[idx + mem[64] + 164] = mem[idx + 128]
                          idx = idx + 32
                          continue 
                      if ceil32(mem[96]) <= mem[96]:
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if mem[96]:
                                      revert with memory
                                        from 128
                                         len mem[96]
                              else:
                                  if return_data.size:
                                      revert with ext_call.return_data[0 len return_data.size]
                          else:
                              _1555 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                              require mem[_1555] == Mask(32, 224, mem[_1555])
                      else:
                          mem[mem[96] + mem[64] + 164] = 0
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if mem[96]:
                                      revert with memory
                                        from 128
                                         len mem[96]
                              else:
                                  if return_data.size:
                                      revert with ext_call.return_data[0 len return_data.size]
                          else:
                              _1556 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                              require mem[_1556] == Mask(32, 224, mem[_1556])
          else:
              if stor1 <= tokenId:
                  revert with 0, 'ERC721A: approved query for nonexistent token'
              if approved[tokenId] == caller:
                  if stor4[idx].field_0 != from:
                      revert with 0, 'ERC721A: transfer from incorrect owner'
                  if not to:
                      revert with 0, 'ERC721A: transfer to the zero address'
                  approved[tokenId] = 0
                  log Approval(
                        address owner=stor4[idx].field_0,
                        address spender=0,
                        uint256 value=tokenId)
                  if balanceOf[address(from)].field_0 < 1:
                      revert with 0, 17
                  balanceOf[address(from)].field_0 = uint128(balanceOf[address(from)].field_0 - 1)
                  mem[0] = to
                  mem[32] = 5
                  if balanceOf[address(to)].field_0 > LOCK8605463013():
                      revert with 0, 17
                  balanceOf[address(to)].field_0 = uint128(balanceOf[address(to)].field_0 + 1)
                  _851 = mem[64]
                  mem[64] = mem[64] + 64
                  mem[_851] = to
                  mem[_851 + 32] = uint64(block.timestamp)
                  stor4[tokenId].field_0 = to
                  stor4[tokenId].field_160 = uint64(block.timestamp)
                  if 1 > !tokenId:
                      revert with 0, 17
                  mem[0] = tokenId + 1
                  mem[32] = 4
                  if stor4[tokenId + 1].field_0:
                      log Transfer(
                            address from=from,
                            address to=to,
                            uint256 value=tokenId)
                      if not ext_code.size(to):
                          stop
                      mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                      mem[mem[64] + 4] = caller
                      mem[mem[64] + 36] = from
                      mem[mem[64] + 68] = tokenId
                      mem[mem[64] + 100] = 128
                      mem[mem[64] + 132] = mem[96]
                      idx = 0
                      while idx < mem[96]:
                          mem[idx + mem[64] + 164] = mem[idx + 128]
                          idx = idx + 32
                          continue 
                      if ceil32(mem[96]) <= mem[96]:
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if mem[96]:
                                      revert with memory
                                        from 128
                                         len mem[96]
                              else:
                                  if return_data.size:
                                      revert with ext_call.return_data[0 len return_data.size]
                          else:
                              _1557 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                              require mem[_1557] == Mask(32, 224, mem[_1557])
                      else:
                          mem[mem[96] + mem[64] + 164] = 0
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if mem[96]:
                                      revert with memory
                                        from 128
                                         len mem[96]
                              else:
                                  if return_data.size:
                                      revert with ext_call.return_data[0 len return_data.size]
                          else:
                              _1558 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                              require mem[_1558] == Mask(32, 224, mem[_1558])
                  else:
                      if stor1 <= tokenId + 1:
                          log Transfer(
                                address from=from,
                                address to=to,
                                uint256 value=tokenId)
                          if not ext_code.size(to):
                              stop
                          mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                          mem[mem[64] + 4] = caller
                          mem[mem[64] + 36] = from
                          mem[mem[64] + 68] = tokenId
                          mem[mem[64] + 100] = 128
                          mem[mem[64] + 132] = mem[96]
                          idx = 0
                          while idx < mem[96]:
                              mem[idx + mem[64] + 164] = mem[idx + 128]
                              idx = idx + 32
                              continue 
                          if ceil32(mem[96]) <= mem[96]:
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if not return_data.size:
                                      if mem[96]:
                                          revert with memory
                                            from 128
                                             len mem[96]
                                  else:
                                      if return_data.size:
                                          revert with ext_call.return_data[0 len return_data.size]
                              else:
                                  _1559 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
                                  require mem[_1559] == Mask(32, 224, mem[_1559])
                          else:
                              mem[mem[96] + mem[64] + 164] = 0
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if not return_data.size:
                                      if mem[96]:
                                          revert with memory
                                            from 128
                                             len mem[96]
                                  else:
                                      if return_data.size:
                                          revert with ext_call.return_data[0 len return_data.size]
                              else:
                                  _1560 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
                                  require mem[_1560] == Mask(32, 224, mem[_1560])
                      else:
                          _904 = mem[64]
                          mem[64] = mem[64] + 64
                          mem[_904] = stor4[idx].field_0
                          mem[_904 + 32] = stor4[idx].field_160
                          mem[0] = tokenId + 1
                          mem[32] = 4
                          stor4[tokenId + 1].field_0 = stor4[idx].field_0
                          stor4[tokenId + 1].field_160 = stor4[idx].field_160
                          log Transfer(
                                address from=from,
                                address to=to,
                                uint256 value=tokenId)
                          if not ext_code.size(to):
                              stop
                          mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                          mem[mem[64] + 4] = caller
                          mem[mem[64] + 36] = from
                          mem[mem[64] + 68] = tokenId
                          mem[mem[64] + 100] = 128
                          mem[mem[64] + 132] = mem[96]
                          idx = 0
                          while idx < mem[96]:
                              mem[idx + mem[64] + 164] = mem[idx + 128]
                              idx = idx + 32
                              continue 
                          if ceil32(mem[96]) <= mem[96]:
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if not return_data.size:
                                      if mem[96]:
                                          revert with memory
                                            from 128
                                             len mem[96]
                                  else:
                                      if return_data.size:
                                          revert with ext_call.return_data[0 len return_data.size]
                              else:
                                  _1561 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
                                  require mem[_1561] == Mask(32, 224, mem[_1561])
                          else:
                              mem[mem[96] + mem[64] + 164] = 0
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if not return_data.size:
                                      if mem[96]:
                                          revert with memory
                                            from 128
                                             len mem[96]
                                  else:
                                      if return_data.size:
                                          revert with ext_call.return_data[0 len return_data.size]
                              else:
                                  _1562 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
                                  require mem[_1562] == Mask(32, 224, mem[_1562])
              else:
                  if not stor7[stor4[idx].field_0][caller]:
                      revert with 0, 'ERC721A: transfer caller is not owner nor approved'
                  if stor4[idx].field_0 != from:
                      revert with 0, 'ERC721A: transfer from incorrect owner'
                  if not to:
                      revert with 0, 'ERC721A: transfer to the zero address'
                  approved[tokenId] = 0
                  log Approval(
                        address owner=stor4[idx].field_0,
                        address spender=0,
                        uint256 value=tokenId)
                  if balanceOf[address(from)].field_0 < 1:
                      revert with 0, 17
                  balanceOf[address(from)].field_0 = uint128(balanceOf[address(from)].field_0 - 1)
                  mem[0] = to
                  mem[32] = 5
                  if balanceOf[address(to)].field_0 > LOCK8605463013():
                      revert with 0, 17
                  balanceOf[address(to)].field_0 = uint128(balanceOf[address(to)].field_0 + 1)
                  _877 = mem[64]
                  mem[64] = mem[64] + 64
                  mem[_877] = to
                  mem[_877 + 32] = uint64(block.timestamp)
                  stor4[tokenId].field_0 = to
                  stor4[tokenId].field_160 = uint64(block.timestamp)
                  if 1 > !tokenId:
                      revert with 0, 17
                  mem[0] = tokenId + 1
                  mem[32] = 4
                  if stor4[tokenId + 1].field_0:
                      log Transfer(
                            address from=from,
                            address to=to,
                            uint256 value=tokenId)
                      if not ext_code.size(to):
                          stop
                      mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                      mem[mem[64] + 4] = caller
                      mem[mem[64] + 36] = from
                      mem[mem[64] + 68] = tokenId
                      mem[mem[64] + 100] = 128
                      mem[mem[64] + 132] = mem[96]
                      idx = 0
                      while idx < mem[96]:
                          mem[idx + mem[64] + 164] = mem[idx + 128]
                          idx = idx + 32
                          continue 
                      if ceil32(mem[96]) <= mem[96]:
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if mem[96]:
                                      revert with memory
                                        from 128
                                         len mem[96]
                              else:
                                  if return_data.size:
                                      revert with ext_call.return_data[0 len return_data.size]
                          else:
                              _1563 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                              require mem[_1563] == Mask(32, 224, mem[_1563])
                      else:
                          mem[mem[96] + mem[64] + 164] = 0
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if mem[96]:
                                      revert with memory
                                        from 128
                                         len mem[96]
                              else:
                                  if return_data.size:
                                      revert with ext_call.return_data[0 len return_data.size]
                          else:
                              _1564 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                              require mem[_1564] == Mask(32, 224, mem[_1564])
                  else:
                      if stor1 <= tokenId + 1:
                          log Transfer(
                                address from=from,
                                address to=to,
                                uint256 value=tokenId)
                          if not ext_code.size(to):
                              stop
                          mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                          mem[mem[64] + 4] = caller
                          mem[mem[64] + 36] = from
                          mem[mem[64] + 68] = tokenId
                          mem[mem[64] + 100] = 128
                          mem[mem[64] + 132] = mem[96]
                          idx = 0
                          while idx < mem[96]:
                              mem[idx + mem[64] + 164] = mem[idx + 128]
                              idx = idx + 32
                              continue 
                          if ceil32(mem[96]) <= mem[96]:
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if not return_data.size:
                                      if mem[96]:
                                          revert with memory
                                            from 128
                                             len mem[96]
                                  else:
                                      if return_data.size:
                                          revert with ext_call.return_data[0 len return_data.size]
                              else:
                                  _1565 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
                                  require mem[_1565] == Mask(32, 224, mem[_1565])
                          else:
                              mem[mem[96] + mem[64] + 164] = 0
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if not return_data.size:
                                      if mem[96]:
                                          revert with memory
                                            from 128
                                             len mem[96]
                                  else:
                                      if return_data.size:
                                          revert with ext_call.return_data[0 len return_data.size]
                              else:
                                  _1566 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
                                  require mem[_1566] == Mask(32, 224, mem[_1566])
                      else:
                          _934 = mem[64]
                          mem[64] = mem[64] + 64
                          mem[_934] = stor4[idx].field_0
                          mem[_934 + 32] = stor4[idx].field_160
                          mem[0] = tokenId + 1
                          mem[32] = 4
                          stor4[tokenId + 1].field_0 = stor4[idx].field_0
                          stor4[tokenId + 1].field_160 = stor4[idx].field_160
                          log Transfer(
                                address from=from,
                                address to=to,
                                uint256 value=tokenId)
                          if not ext_code.size(to):
                              stop
                          mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                          mem[mem[64] + 4] = caller
                          mem[mem[64] + 36] = from
                          mem[mem[64] + 68] = tokenId
                          mem[mem[64] + 100] = 128
                          mem[mem[64] + 132] = mem[96]
                          idx = 0
                          while idx < mem[96]:
                              mem[idx + mem[64] + 164] = mem[idx + 128]
                              idx = idx + 32
                              continue 
                          if ceil32(mem[96]) <= mem[96]:
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if not return_data.size:
                                      if mem[96]:
                                          revert with memory
                                            from 128
                                             len mem[96]
                                  else:
                                      if return_data.size:
                                          revert with ext_call.return_data[0 len return_data.size]
                              else:
                                  _1567 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
                                  require mem[_1567] == Mask(32, 224, mem[_1567])
                          else:
                              mem[mem[96] + mem[64] + 164] = 0
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if not return_data.size:
                                      if mem[96]:
                                          revert with memory
                                            from 128
                                             len mem[96]
                                  else:
                                      if return_data.size:
                                          revert with ext_call.return_data[0 len return_data.size]
                              else:
                                  _1568 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
                                  require mem[_1568] == Mask(32, 224, mem[_1568])
          ...  # Decompilation aborted, sorry: ("decompilation didn't finish",)
  else:
      if 1 > !(tokenId - 2500):
          revert with 0, 17
      idx = tokenId
      while idx >= tokenId - 2499:
          mem[0] = idx
          mem[32] = 4
          _756 = mem[64]
          mem[64] = mem[64] + 64
          mem[_756] = stor4[idx].field_0
          mem[_756 + 32] = stor4[idx].field_160
          if not stor4[idx].field_0:
              if not idx:
                  revert with 0, 17
              idx = idx - 1
              continue 
          if caller == stor4[idx].field_0:
              if stor4[idx].field_0 != from:
                  revert with 0, 'ERC721A: transfer from incorrect owner'
              if not to:
                  revert with 0, 'ERC721A: transfer to the zero address'
              approved[tokenId] = 0
              log Approval(
                    address owner=stor4[idx].field_0,
                    address spender=0,
                    uint256 value=tokenId)
              if balanceOf[address(from)].field_0 < 1:
                  revert with 0, 17
              balanceOf[address(from)].field_0 = uint128(balanceOf[address(from)].field_0 - 1)
              mem[0] = to
              mem[32] = 5
              if balanceOf[address(to)].field_0 > LOCK8605463013():
                  revert with 0, 17
              balanceOf[address(to)].field_0 = uint128(balanceOf[address(to)].field_0 + 1)
              _832 = mem[64]
              mem[64] = mem[64] + 64
              mem[_832] = to
              mem[_832 + 32] = uint64(block.timestamp)
              stor4[tokenId].field_0 = to
              stor4[tokenId].field_160 = uint64(block.timestamp)
              if 1 > !tokenId:
                  revert with 0, 17
              mem[0] = tokenId + 1
              mem[32] = 4
              if stor4[tokenId + 1].field_0:
                  log Transfer(
                        address from=from,
                        address to=to,
                        uint256 value=tokenId)
                  if not ext_code.size(to):
                      stop
                  mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                  mem[mem[64] + 4] = caller
                  mem[mem[64] + 36] = from
                  mem[mem[64] + 68] = tokenId
                  mem[mem[64] + 100] = 128
                  mem[mem[64] + 132] = mem[96]
                  idx = 0
                  while idx < mem[96]:
                      mem[idx + mem[64] + 164] = mem[idx + 128]
                      idx = idx + 32
                      continue 
                  if ceil32(mem[96]) <= mem[96]:
                      require ext_code.size(to)
                      call to.onERC721Received(address , address , uint256 , bytes ) with:
                           gas gas_remaining wei
                          args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                      mem[mem[64]] = ext_call.return_data[0]
                      if not ext_call.success:
                          if not return_data.size:
                              if mem[96]:
                                  revert with memory
                                    from 128
                                     len mem[96]
                          else:
                              if return_data.size:
                                  revert with ext_call.return_data[0 len return_data.size]
                      else:
                          _1569 = mem[64]
                          mem[64] = mem[64] + ceil32(return_data.size)
                          require return_data.size >=′ 32
                          require mem[_1569] == Mask(32, 224, mem[_1569])
                  else:
                      mem[mem[96] + mem[64] + 164] = 0
                      require ext_code.size(to)
                      call to.onERC721Received(address , address , uint256 , bytes ) with:
                           gas gas_remaining wei
                          args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                      mem[mem[64]] = ext_call.return_data[0]
                      if not ext_call.success:
                          if not return_data.size:
                              if mem[96]:
                                  revert with memory
                                    from 128
                                     len mem[96]
                          else:
                              if return_data.size:
                                  revert with ext_call.return_data[0 len return_data.size]
                      else:
                          _1570 = mem[64]
                          mem[64] = mem[64] + ceil32(return_data.size)
                          require return_data.size >=′ 32
                          require mem[_1570] == Mask(32, 224, mem[_1570])
              else:
                  if stor1 <= tokenId + 1:
                      log Transfer(
                            address from=from,
                            address to=to,
                            uint256 value=tokenId)
                      if not ext_code.size(to):
                          stop
                      mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                      mem[mem[64] + 4] = caller
                      mem[mem[64] + 36] = from
                      mem[mem[64] + 68] = tokenId
                      mem[mem[64] + 100] = 128
                      mem[mem[64] + 132] = mem[96]
                      idx = 0
                      while idx < mem[96]:
                          mem[idx + mem[64] + 164] = mem[idx + 128]
                          idx = idx + 32
                          continue 
                      if ceil32(mem[96]) <= mem[96]:
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if mem[96]:
                                      revert with memory
                                        from 128
                                         len mem[96]
                              else:
                                  if return_data.size:
                                      revert with ext_call.return_data[0 len return_data.size]
                          else:
                              _1571 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                              require mem[_1571] == Mask(32, 224, mem[_1571])
                      else:
                          mem[mem[96] + mem[64] + 164] = 0
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if mem[96]:
                                      revert with memory
                                        from 128
                                         len mem[96]
                              else:
                                  if return_data.size:
                                      revert with ext_call.return_data[0 len return_data.size]
                          else:
                              _1572 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                              require mem[_1572] == Mask(32, 224, mem[_1572])
                  else:
                      _869 = mem[64]
                      mem[64] = mem[64] + 64
                      mem[_869] = stor4[idx].field_0
                      mem[_869 + 32] = stor4[idx].field_160
                      mem[0] = tokenId + 1
                      mem[32] = 4
                      stor4[tokenId + 1].field_0 = stor4[idx].field_0
                      stor4[tokenId + 1].field_160 = stor4[idx].field_160
                      log Transfer(
                            address from=from,
                            address to=to,
                            uint256 value=tokenId)
                      if not ext_code.size(to):
                          stop
                      mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                      mem[mem[64] + 4] = caller
                      mem[mem[64] + 36] = from
                      mem[mem[64] + 68] = tokenId
                      mem[mem[64] + 100] = 128
                      mem[mem[64] + 132] = mem[96]
                      idx = 0
                      while idx < mem[96]:
                          mem[idx + mem[64] + 164] = mem[idx + 128]
                          idx = idx + 32
                          continue 
                      if ceil32(mem[96]) <= mem[96]:
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if mem[96]:
                                      revert with memory
                                        from 128
                                         len mem[96]
                              else:
                                  if return_data.size:
                                      revert with ext_call.return_data[0 len return_data.size]
                          else:
                              _1573 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                              require mem[_1573] == Mask(32, 224, mem[_1573])
                      else:
                          mem[mem[96] + mem[64] + 164] = 0
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if mem[96]:
                                      revert with memory
                                        from 128
                                         len mem[96]
                              else:
                                  if return_data.size:
                                      revert with ext_call.return_data[0 len return_data.size]
                          else:
                              _1574 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                              require mem[_1574] == Mask(32, 224, mem[_1574])
          else:
              if stor1 <= tokenId:
                  revert with 0, 'ERC721A: approved query for nonexistent token'
              if approved[tokenId] == caller:
                  if stor4[idx].field_0 != from:
                      revert with 0, 'ERC721A: transfer from incorrect owner'
                  if not to:
                      revert with 0, 'ERC721A: transfer to the zero address'
                  approved[tokenId] = 0
                  log Approval(
                        address owner=stor4[idx].field_0,
                        address spender=0,
                        uint256 value=tokenId)
                  if balanceOf[address(from)].field_0 < 1:
                      revert with 0, 17
                  balanceOf[address(from)].field_0 = uint128(balanceOf[address(from)].field_0 - 1)
                  mem[0] = to
                  mem[32] = 5
                  if balanceOf[address(to)].field_0 > LOCK8605463013():
                      revert with 0, 17
                  balanceOf[address(to)].field_0 = uint128(balanceOf[address(to)].field_0 + 1)
                  _855 = mem[64]
                  mem[64] = mem[64] + 64
                  mem[_855] = to
                  mem[_855 + 32] = uint64(block.timestamp)
                  stor4[tokenId].field_0 = to
                  stor4[tokenId].field_160 = uint64(block.timestamp)
                  if 1 > !tokenId:
                      revert with 0, 17
                  mem[0] = tokenId + 1
                  mem[32] = 4
                  if stor4[tokenId + 1].field_0:
                      log Transfer(
                            address from=from,
                            address to=to,
                            uint256 value=tokenId)
                      if not ext_code.size(to):
                          stop
                      mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                      mem[mem[64] + 4] = caller
                      mem[mem[64] + 36] = from
                      mem[mem[64] + 68] = tokenId
                      mem[mem[64] + 100] = 128
                      mem[mem[64] + 132] = mem[96]
                      idx = 0
                      while idx < mem[96]:
                          mem[idx + mem[64] + 164] = mem[idx + 128]
                          idx = idx + 32
                          continue 
                      if ceil32(mem[96]) <= mem[96]:
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if mem[96]:
                                      revert with memory
                                        from 128
                                         len mem[96]
                              else:
                                  if return_data.size:
                                      revert with ext_call.return_data[0 len return_data.size]
                          else:
                              _1575 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                              require mem[_1575] == Mask(32, 224, mem[_1575])
                      else:
                          mem[mem[96] + mem[64] + 164] = 0
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if mem[96]:
                                      revert with memory
                                        from 128
                                         len mem[96]
                              else:
                                  if return_data.size:
                                      revert with ext_call.return_data[0 len return_data.size]
                          else:
                              _1576 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                              require mem[_1576] == Mask(32, 224, mem[_1576])
                  else:
                      if stor1 <= tokenId + 1:
                          log Transfer(
                                address from=from,
                                address to=to,
                                uint256 value=tokenId)
                          if not ext_code.size(to):
                              stop
                          mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                          mem[mem[64] + 4] = caller
                          mem[mem[64] + 36] = from
                          mem[mem[64] + 68] = tokenId
                          mem[mem[64] + 100] = 128
                          mem[mem[64] + 132] = mem[96]
                          idx = 0
                          while idx < mem[96]:
                              mem[idx + mem[64] + 164] = mem[idx + 128]
                              idx = idx + 32
                              continue 
                          if ceil32(mem[96]) <= mem[96]:
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if not return_data.size:
                                      if mem[96]:
                                          revert with memory
                                            from 128
                                             len mem[96]
                                  else:
                                      if return_data.size:
                                          revert with ext_call.return_data[0 len return_data.size]
                              else:
                                  _1577 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
                                  require mem[_1577] == Mask(32, 224, mem[_1577])
                          else:
                              mem[mem[96] + mem[64] + 164] = 0
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if not return_data.size:
                                      if mem[96]:
                                          revert with memory
                                            from 128
                                             len mem[96]
                                  else:
                                      if return_data.size:
                                          revert with ext_call.return_data[0 len return_data.size]
                              else:
                                  _1578 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
                                  require mem[_1578] == Mask(32, 224, mem[_1578])
                      else:
                          _915 = mem[64]
                          mem[64] = mem[64] + 64
                          mem[_915] = stor4[idx].field_0
                          mem[_915 + 32] = stor4[idx].field_160
                          mem[0] = tokenId + 1
                          mem[32] = 4
                          stor4[tokenId + 1].field_0 = stor4[idx].field_0
                          stor4[tokenId + 1].field_160 = stor4[idx].field_160
                          log Transfer(
                                address from=from,
                                address to=to,
                                uint256 value=tokenId)
                          if not ext_code.size(to):
                              stop
                          mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                          mem[mem[64] + 4] = caller
                          mem[mem[64] + 36] = from
                          mem[mem[64] + 68] = tokenId
                          mem[mem[64] + 100] = 128
                          mem[mem[64] + 132] = mem[96]
                          idx = 0
                          while idx < mem[96]:
                              mem[idx + mem[64] + 164] = mem[idx + 128]
                              idx = idx + 32
                              continue 
                          if ceil32(mem[96]) <= mem[96]:
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if not return_data.size:
                                      if mem[96]:
                                          revert with memory
                                            from 128
                                             len mem[96]
                                  else:
                                      if return_data.size:
                                          revert with ext_call.return_data[0 len return_data.size]
                              else:
                                  _1579 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
                                  require mem[_1579] == Mask(32, 224, mem[_1579])
                          else:
                              mem[mem[96] + mem[64] + 164] = 0
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if not return_data.size:
                                      if mem[96]:
                                          revert with memory
                                            from 128
                                             len mem[96]
                                  else:
                                      if return_data.size:
                                          revert with ext_call.return_data[0 len return_data.size]
                              else:
                                  _1580 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
                                  require mem[_1580] == Mask(32, 224, mem[_1580])
              else:
                  if not stor7[stor4[idx].field_0][caller]:
                      revert with 0, 'ERC721A: transfer caller is not owner nor approved'
                  if stor4[idx].field_0 != from:
                      revert with 0, 'ERC721A: transfer from incorrect owner'
                  if not to:
                      revert with 0, 'ERC721A: transfer to the zero address'
                  approved[tokenId] = 0
                  log Approval(
                        address owner=stor4[idx].field_0,
                        address spender=0,
                        uint256 value=tokenId)
                  if balanceOf[address(from)].field_0 < 1:
                      revert with 0, 17
                  balanceOf[address(from)].field_0 = uint128(balanceOf[address(from)].field_0 - 1)
                  mem[0] = to
                  mem[32] = 5
                  if balanceOf[address(to)].field_0 > LOCK8605463013():
                      revert with 0, 17
                  balanceOf[address(to)].field_0 = uint128(balanceOf[address(to)].field_0 + 1)
                  _883 = mem[64]
                  mem[64] = mem[64] + 64
                  mem[_883] = to
                  mem[_883 + 32] = uint64(block.timestamp)
                  stor4[tokenId].field_0 = to
                  stor4[tokenId].field_160 = uint64(block.timestamp)
                  if 1 > !tokenId:
                      revert with 0, 17
                  mem[0] = tokenId + 1
                  mem[32] = 4
                  if stor4[tokenId + 1].field_0:
                      log Transfer(
                            address from=from,
                            address to=to,
                            uint256 value=tokenId)
                      if not ext_code.size(to):
                          stop
                      mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                      mem[mem[64] + 4] = caller
                      mem[mem[64] + 36] = from
                      mem[mem[64] + 68] = tokenId
                      mem[mem[64] + 100] = 128
                      mem[mem[64] + 132] = mem[96]
                      idx = 0
                      while idx < mem[96]:
                          mem[idx + mem[64] + 164] = mem[idx + 128]
                          idx = idx + 32
                          continue 
                      if ceil32(mem[96]) <= mem[96]:
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if mem[96]:
                                      revert with memory
                                        from 128
                                         len mem[96]
                              else:
                                  if return_data.size:
                                      revert with ext_call.return_data[0 len return_data.size]
                          else:
                              _1581 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                              require mem[_1581] == Mask(32, 224, mem[_1581])
                      else:
                          mem[mem[96] + mem[64] + 164] = 0
                          require ext_code.size(to)
                          call to.onERC721Received(address , address , uint256 , bytes ) with:
                               gas gas_remaining wei
                              args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                          mem[mem[64]] = ext_call.return_data[0]
                          if not ext_call.success:
                              if not return_data.size:
                                  if mem[96]:
                                      revert with memory
                                        from 128
                                         len mem[96]
                              else:
                                  if return_data.size:
                                      revert with ext_call.return_data[0 len return_data.size]
                          else:
                              _1582 = mem[64]
                              mem[64] = mem[64] + ceil32(return_data.size)
                              require return_data.size >=′ 32
                              require mem[_1582] == Mask(32, 224, mem[_1582])
                  else:
                      if stor1 <= tokenId + 1:
                          log Transfer(
                                address from=from,
                                address to=to,
                                uint256 value=tokenId)
                          if not ext_code.size(to):
                              stop
                          mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                          mem[mem[64] + 4] = caller
                          mem[mem[64] + 36] = from
                          mem[mem[64] + 68] = tokenId
                          mem[mem[64] + 100] = 128
                          mem[mem[64] + 132] = mem[96]
                          idx = 0
                          while idx < mem[96]:
                              mem[idx + mem[64] + 164] = mem[idx + 128]
                              idx = idx + 32
                              continue 
                          if ceil32(mem[96]) <= mem[96]:
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if not return_data.size:
                                      if mem[96]:
                                          revert with memory
                                            from 128
                                             len mem[96]
                                  else:
                                      if return_data.size:
                                          revert with ext_call.return_data[0 len return_data.size]
                              else:
                                  _1583 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
                                  require mem[_1583] == Mask(32, 224, mem[_1583])
                          else:
                              mem[mem[96] + mem[64] + 164] = 0
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if not return_data.size:
                                      if mem[96]:
                                          revert with memory
                                            from 128
                                             len mem[96]
                                  else:
                                      if return_data.size:
                                          revert with ext_call.return_data[0 len return_data.size]
                              else:
                                  _1584 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
                                  require mem[_1584] == Mask(32, 224, mem[_1584])
                      else:
                          _945 = mem[64]
                          mem[64] = mem[64] + 64
                          mem[_945] = stor4[idx].field_0
                          mem[_945 + 32] = stor4[idx].field_160
                          mem[0] = tokenId + 1
                          mem[32] = 4
                          stor4[tokenId + 1].field_0 = stor4[idx].field_0
                          stor4[tokenId + 1].field_160 = stor4[idx].field_160
                          log Transfer(
                                address from=from,
                                address to=to,
                                uint256 value=tokenId)
                          if not ext_code.size(to):
                              stop
                          mem[mem[64]] = 0x150b7a0200000000000000000000000000000000000000000000000000000000
                          mem[mem[64] + 4] = caller
                          mem[mem[64] + 36] = from
                          mem[mem[64] + 68] = tokenId
                          mem[mem[64] + 100] = 128
                          mem[mem[64] + 132] = mem[96]
                          idx = 0
                          while idx < mem[96]:
                              mem[idx + mem[64] + 164] = mem[idx + 128]
                              idx = idx + 32
                              continue 
                          if ceil32(mem[96]) <= mem[96]:
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if not return_data.size:
                                      if mem[96]:
                                          revert with memory
                                            from 128
                                             len mem[96]
                                  else:
                                      if return_data.size:
                                          revert with ext_call.return_data[0 len return_data.size]
                              else:
                                  _1585 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
                                  require mem[_1585] == Mask(32, 224, mem[_1585])
                          else:
                              mem[mem[96] + mem[64] + 164] = 0
                              require ext_code.size(to)
                              call to.onERC721Received(address , address , uint256 , bytes ) with:
                                   gas gas_remaining wei
                                  args caller, address(from), tokenId, Array(len=mem[96], data=mem[mem[64] + 164 len ceil32(mem[96])])
                              mem[mem[64]] = ext_call.return_data[0]
                              if not ext_call.success:
                                  if not return_data.size:
                                      if mem[96]:
                                          revert with memory
                                            from 128
                                             len mem[96]
                                  else:
                                      if return_data.size:
                                          revert with ext_call.return_data[0 len return_data.size]
                              else:
                                  _1586 = mem[64]
                                  mem[64] = mem[64] + ceil32(return_data.size)
                                  require return_data.size >=′ 32
                                  require mem[_1586] == Mask(32, 224, mem[_1586])
          ...  # Decompilation aborted, sorry: ("decompilation didn't finish",)
  revert with 0, 'ERC721A: unable to determine the owner of token'