{
  "language": "Solidity",
  "sources": {
    "contracts/DCNT721A.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/*\n ______   _______  _______  _______  _       _________\n(  __  \\ (  ____ \\(  ____ \\(  ____ \\( (    /|\\__   __/\n| (  \\  )| (    \\/| (    \\/| (    \\/|  \\  ( |   ) (\n| |   ) || (__    | |      | (__    |   \\ | |   | |\n| |   | ||  __)   | |      |  __)   | (\\ \\) |   | |\n| |   ) || (      | |      | (      | | \\   |   | |\n| (__/  )| (____/\\| (____/\\| (____/\\| )  \\  |   | |\n(______/ (_______/(_______/(_______/|/    )_)   )_(\n\n*/\n\n/// ============ Imports ============\n\nimport \"./erc721a/ERC721A.sol\";\nimport \"./interfaces/IMetadataRenderer.sol\";\nimport \"@openzeppelin/contracts/proxy/utils/Initializable.sol\";\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\nimport \"./storage/EditionConfig.sol\";\nimport \"./storage/MetadataConfig.sol\";\nimport \"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\";\nimport \"./storage/DCNT721AStorage.sol\";\nimport \"./utils/Splits.sol\";\nimport './interfaces/ITokenWithBalance.sol';\n\n/// @title template NFT contract\ncontract DCNT721A is ERC721A, DCNT721AStorage, Initializable, Ownable, Splits {\n\n  bool public hasAdjustableCap;\n  uint256 public MAX_TOKENS;\n  uint256 public tokenPrice;\n  uint256 public maxTokenPurchase;\n\n  uint256 public saleStart;\n  uint256 public saleEnd;\n  bool public saleIsPaused;\n  string public baseURI;\n  string internal _contractURI;\n  address public metadataRenderer;\n  uint256 public royaltyBPS;\n\n  uint256 public presaleStart;\n  uint256 public presaleEnd;\n  bytes32 internal presaleMerkleRoot;\n\n  address public splitMain;\n  address public splitWallet;\n  address public parentIP;\n\n  /// ============ Events ============\n\n  /// @notice Emitted after a successful token claim\n  /// @param sender recipient of NFT mint\n  /// @param tokenId_ of token minted\n  event Minted(address sender, uint256 tokenId_);\n\n  /// ========== Modifier =============\n  /// @notice verifies caller has minimum balance to pass through token gate\n  modifier verifyTokenGate(bool isPresale) {\n    if (tokenGateConfig.tokenAddress != address(0)\n      && (tokenGateConfig.saleType == SaleType.ALL ||\n          isPresale && tokenGateConfig.saleType == SaleType.PRESALE) ||\n          !isPresale && tokenGateConfig.saleType == SaleType.PRIMARY) {\n            require(ITokenWithBalance(tokenGateConfig.tokenAddress).balanceOf(msg.sender) >= tokenGateConfig.minBalance, 'do not own required token');\n    }\n\n    _;\n  }\n\n  /// ============ Constructor ============\n\n  function initialize(\n    address _owner,\n    EditionConfig memory _editionConfig,\n    MetadataConfig memory _metadataConfig,\n    TokenGateConfig memory _tokenGateConfig,\n    address _metadataRenderer,\n    address _splitMain\n  ) public initializer {\n    _transferOwnership(_owner);\n    _name = _editionConfig.name;\n    _symbol = _editionConfig.symbol;\n    _currentIndex = _startTokenId();\n    MAX_TOKENS = _editionConfig.maxTokens;\n    tokenPrice = _editionConfig.tokenPrice;\n    maxTokenPurchase = _editionConfig.maxTokenPurchase;\n    saleStart = _editionConfig.saleStart;\n    saleEnd = _editionConfig.saleEnd;\n    royaltyBPS = _editionConfig.royaltyBPS;\n    hasAdjustableCap = _editionConfig.hasAdjustableCap;\n    parentIP = _metadataConfig.parentIP;\n    splitMain = _splitMain;\n    tokenGateConfig = _tokenGateConfig;\n    presaleMerkleRoot = _editionConfig.presaleMerkleRoot;\n    presaleStart = _editionConfig.presaleStart;\n    presaleEnd = _editionConfig.presaleEnd;\n\n    if (\n      _metadataRenderer != address(0) &&\n      _metadataConfig.metadataRendererInit.length > 0\n    ) {\n      metadataRenderer = _metadataRenderer;\n      IMetadataRenderer(_metadataRenderer).initializeWithData(\n        _metadataConfig.metadataRendererInit\n      );\n    } else {\n      _contractURI = _metadataConfig.contractURI;\n      baseURI = _metadataConfig.metadataURI;\n    }\n  }\n\n  /// @notice purchase nft\n  function mint(uint256 numberOfTokens)\n    external\n    payable\n    verifyTokenGate(false)\n  {\n    uint256 mintIndex = _nextTokenId();\n    require(block.timestamp >= saleStart && block.timestamp <= saleEnd, \"Sales are not active.\");\n    require(!saleIsPaused, \"Sale must be active to mint\");\n    require(\n      mintIndex + numberOfTokens <= MAX_TOKENS,\n      \"Purchase would exceed max supply\"\n    );\n    require(mintIndex <= MAX_TOKENS, \"SOLD OUT\");\n    require(msg.value >= (tokenPrice * numberOfTokens), \"Insufficient funds\");\n    if ( maxTokenPurchase != 0 ) {\n      require(numberOfTokens <= maxTokenPurchase, \"Exceeded max number per mint\");\n    }\n\n    _safeMint(msg.sender, numberOfTokens);\n    unchecked {\n      for (uint256 i = 0; i < numberOfTokens; i++) {\n        emit Minted(msg.sender, mintIndex++);\n      }\n    }\n  }\n\n  /// @notice allows the owner to \"airdrop\" users an NFT\n  function mintAirdrop(address[] calldata recipients) external onlyOwner {\n    uint256 atId = _nextTokenId();\n    uint256 startAt = atId;\n    require(atId + recipients.length <= MAX_TOKENS,\n      \"Purchase would exceed max supply\"\n    );\n\n    unchecked {\n      for (\n        uint256 endAt = atId + recipients.length;\n        atId < endAt;\n        atId++\n      ) {\n        _safeMint(recipients[atId - startAt], 1);\n        emit Minted(recipients[atId - startAt], atId);\n      }\n    }\n  }\n\n  /// @notice presale mint function\n  function mintPresale(\n    uint256 quantity,\n    uint256 maxQuantity,\n    uint256 pricePerToken,\n    bytes32[] calldata merkleProof\n  )\n    external\n    payable\n    verifyTokenGate(true)\n  {\n    require (block.timestamp >= presaleStart && block.timestamp <= presaleEnd, 'not presale');\n    uint256 mintIndex = _nextTokenId();\n    require(!saleIsPaused, \"Sale must be active to mint\");\n    require(\n      mintIndex + quantity <= MAX_TOKENS,\n      \"Purchase would exceed max supply\"\n    );\n    require (MerkleProof.verify(\n        merkleProof,\n        presaleMerkleRoot,\n        keccak256(\n          // address, uint256, uint256\n          abi.encodePacked(msg.sender,maxQuantity,pricePerToken)\n        )\n      ), 'not approved');\n\n    require(msg.value >= (pricePerToken * quantity), \"Insufficient funds\");\n    require(balanceOf(msg.sender) + quantity <= maxQuantity, 'minted too many');\n    _safeMint(msg.sender, quantity);\n    unchecked {\n      for (uint256 i = 0; i < quantity; i++) {\n        emit Minted(msg.sender, mintIndex++);\n      }\n    }\n  }\n\n  function setPresaleMerkleRoot(bytes32 _presaleMerkleRoot) external onlyOwner {\n    presaleMerkleRoot = _presaleMerkleRoot;\n  }\n\n  /// @notice pause or unpause sale\n  function flipSaleState() external onlyOwner {\n    saleIsPaused = !saleIsPaused;\n  }\n\n  /// @notice is the current sale active\n  function saleIsActive() external view returns(bool _saleIsActive) {\n    _saleIsActive = (block.timestamp >= saleStart && block.timestamp <= saleEnd) && (!saleIsPaused);\n  }\n\n  ///change maximum number of tokens available to mint\n  function adjustCap(uint256 newCap) external onlyOwner {\n    require(hasAdjustableCap, 'cannot adjust size of this collection');\n    require(_nextTokenId() <= newCap, 'cannot decrease cap');\n    MAX_TOKENS = newCap;\n  }\n\n  /// @notice withdraw funds from contract to seller funds recipient\n  function withdraw() external onlyOwner {\n    require(\n      _getSplitWallet() == address(0),\n      \"Cannot withdraw with an active split\"\n    );\n\n    (bool success, ) = payable(msg.sender).call{value: address(this).balance}(\"\");\n    require(success, \"Could not withdraw\");\n  }\n\n  function setBaseURI(string memory uri) external onlyOwner {\n    baseURI = uri;\n  }\n\n  function _baseURI() internal view virtual override returns (string memory) {\n    return baseURI;\n  }\n\n  function setMetadataRenderer(address _metadataRenderer) external onlyOwner {\n    metadataRenderer = _metadataRenderer;\n  }\n\n  /// @notice update the contract URI\n  function setContractURI(string memory uri) external onlyOwner {\n    _contractURI = uri;\n  }\n\n  /// @notice view the current contract URI\n  function contractURI()\n    public\n    view\n    virtual\n    returns (string memory)\n  {\n    return (metadataRenderer != address(0))\n      ? IMetadataRenderer(metadataRenderer).contractURI()\n      : _contractURI;\n  }\n\n  /// @notice view the token URI for a given tokenId\n  function tokenURI(uint256 tokenId)\n    public\n    view\n    virtual\n    override\n    returns (string memory)\n  {\n    if (!_exists(tokenId)) revert URIQueryForNonexistentToken();\n\n    if (metadataRenderer != address(0)) {\n      return IMetadataRenderer(metadataRenderer).tokenURI(tokenId);\n    }\n    return super.tokenURI(tokenId);\n  }\n\n  /// @notice save some for creator\n  function reserveDCNT(uint256 numReserved) external onlyOwner {\n    uint256 supply = _nextTokenId();\n    require(\n      supply + numReserved < MAX_TOKENS,\n      \"Purchase would exceed max supply\"\n    );\n    for (uint256 i = 0; i < numReserved; i++) {\n      _safeMint(msg.sender, supply + i + 1);\n    }\n  }\n\n  function royaltyInfo(uint256 tokenId, uint256 salePrice)\n    external\n    view\n    returns (address receiver, uint256 royaltyAmount)\n  {\n    require(_exists(tokenId), \"Nonexistent token\");\n\n    if (splitWallet != address(0)) {\n      receiver = splitWallet;\n    } else {\n      receiver = owner();\n    }\n\n    uint256 royaltyPayment = (salePrice * royaltyBPS) / 10_000;\n\n    return (receiver, royaltyPayment);\n  }\n\n  function supportsInterface(bytes4 interfaceId)\n    public\n    view\n    virtual\n    override(ERC721A)\n    returns (bool)\n  {\n    return\n      interfaceId == 0x2a55205a || // ERC2981 interface ID for ERC2981.\n      super.supportsInterface(interfaceId);\n  }\n\n  function _getSplitMain() internal virtual override returns (address) {\n    return splitMain;\n  }\n\n  function _getSplitWallet() internal virtual override returns (address) {\n    return splitWallet;\n  }\n\n  function _setSplitWallet(address _splitWallet) internal virtual override {\n    splitWallet = _splitWallet;\n  }\n\n  /// @notice update the public sale start time\n  function updateSaleStartEnd(uint256 newStart, uint256 newEnd) external onlyOwner {\n    saleStart = newStart;\n    saleEnd = newEnd;\n  }\n\n  /// @notice update the public sale start time\n  function updatePresaleStartEnd(uint256 newStart, uint256 newEnd) external onlyOwner {\n    presaleStart = newStart;\n    presaleEnd = newEnd;\n  }\n}\n"
    },
    "contracts/erc721a/ERC721A.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// ERC721A Contracts v4.2.2\n// Creator: Chiru Labs\n\npragma solidity ^0.8.4;\n\nimport \"erc721a/contracts/IERC721A.sol\";\n\n/**\n * @dev Interface of ERC721 token receiver.\n */\ninterface ERC721A__IERC721Receiver {\n  function onERC721Received(\n    address operator,\n    address from,\n    uint256 tokenId,\n    bytes calldata data\n  ) external returns (bytes4);\n}\n\n/**\n * @title ERC721A\n *\n * @dev Implementation of the [ERC721](https://eips.ethereum.org/EIPS/eip-721)\n * Non-Fungible Token Standard, including the Metadata extension.\n * Optimized for lower gas during batch mints.\n *\n * Token IDs are minted in sequential order (e.g. 0, 1, 2, 3, ...)\n * starting from `_startTokenId()`.\n *\n * Assumptions:\n *\n * - An owner cannot have more than 2**64 - 1 (max value of uint64) of supply.\n * - The maximum token ID cannot exceed 2**256 - 1 (max value of uint256).\n */\ncontract ERC721A is IERC721A {\n  // Reference type for token approval.\n  struct TokenApprovalRef {\n    address value;\n  }\n\n  // =============================================================\n  //                           CONSTANTS\n  // =============================================================\n\n  // Mask of an entry in packed address data.\n  uint256 private constant _BITMASK_ADDRESS_DATA_ENTRY = (1 << 64) - 1;\n\n  // The bit position of `numberMinted` in packed address data.\n  uint256 private constant _BITPOS_NUMBER_MINTED = 64;\n\n  // The bit position of `numberBurned` in packed address data.\n  uint256 private constant _BITPOS_NUMBER_BURNED = 128;\n\n  // The bit position of `aux` in packed address data.\n  uint256 private constant _BITPOS_AUX = 192;\n\n  // Mask of all 256 bits in packed address data except the 64 bits for `aux`.\n  uint256 private constant _BITMASK_AUX_COMPLEMENT = (1 << 192) - 1;\n\n  // The bit position of `startTimestamp` in packed ownership.\n  uint256 private constant _BITPOS_START_TIMESTAMP = 160;\n\n  // The bit mask of the `burned` bit in packed ownership.\n  uint256 private constant _BITMASK_BURNED = 1 << 224;\n\n  // The bit position of the `nextInitialized` bit in packed ownership.\n  uint256 private constant _BITPOS_NEXT_INITIALIZED = 225;\n\n  // The bit mask of the `nextInitialized` bit in packed ownership.\n  uint256 private constant _BITMASK_NEXT_INITIALIZED = 1 << 225;\n\n  // The bit position of `extraData` in packed ownership.\n  uint256 private constant _BITPOS_EXTRA_DATA = 232;\n\n  // Mask of all 256 bits in a packed ownership except the 24 bits for `extraData`.\n  uint256 private constant _BITMASK_EXTRA_DATA_COMPLEMENT = (1 << 232) - 1;\n\n  // The mask of the lower 160 bits for addresses.\n  uint256 private constant _BITMASK_ADDRESS = (1 << 160) - 1;\n\n  // The maximum `quantity` that can be minted with {_mintERC2309}.\n  // This limit is to prevent overflows on the address data entries.\n  // For a limit of 5000, a total of 3.689e15 calls to {_mintERC2309}\n  // is required to cause an overflow, which is unrealistic.\n  uint256 private constant _MAX_MINT_ERC2309_QUANTITY_LIMIT = 5000;\n\n  // The `Transfer` event signature is given by:\n  // `keccak256(bytes(\"Transfer(address,address,uint256)\"))`.\n  bytes32 private constant _TRANSFER_EVENT_SIGNATURE =\n    0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;\n\n  // =============================================================\n  //                            STORAGE\n  // =============================================================\n\n  // The next token ID to be minted.\n  // internal, set in child initializer\n  uint256 internal _currentIndex;\n\n  // The number of tokens burned.\n  uint256 private _burnCounter;\n\n  // Token name\n  // internal, set in child initializer\n  string internal _name;\n\n  // Token symbol\n  // internal, set in child initializer\n  string internal _symbol;\n\n  // Mapping from token ID to ownership details\n  // An empty struct value does not necessarily mean the token is unowned.\n  // See {_packedOwnershipOf} implementation for details.\n  //\n  // Bits Layout:\n  // - [0..159]   `addr`\n  // - [160..223] `startTimestamp`\n  // - [224]      `burned`\n  // - [225]      `nextInitialized`\n  // - [232..255] `extraData`\n  mapping(uint256 => uint256) private _packedOwnerships;\n\n  // Mapping owner address to address data.\n  //\n  // Bits Layout:\n  // - [0..63]    `balance`\n  // - [64..127]  `numberMinted`\n  // - [128..191] `numberBurned`\n  // - [192..255] `aux`\n  mapping(address => uint256) private _packedAddressData;\n\n  // Mapping from token ID to approved address.\n  mapping(uint256 => TokenApprovalRef) private _tokenApprovals;\n\n  // Mapping from owner to operator approvals\n  mapping(address => mapping(address => bool)) private _operatorApprovals;\n\n  // =============================================================\n  //                          CONSTRUCTOR\n  // =============================================================\n\n  // set _name _symbol and _currentIndex in child initializer\n  constructor() {}\n\n  // =============================================================\n  //                   TOKEN COUNTING OPERATIONS\n  // =============================================================\n\n  /**\n   * @dev Returns the starting token ID.\n   * To change the starting token ID, please override this function.\n   */\n  function _startTokenId() internal view virtual returns (uint256) {\n    return 0;\n  }\n\n  /**\n   * @dev Returns the next token ID to be minted.\n   */\n  function _nextTokenId() internal view virtual returns (uint256) {\n    return _currentIndex;\n  }\n\n  /**\n   * @dev Returns the total number of tokens in existence.\n   * Burned tokens will reduce the count.\n   * To get the total number of tokens minted, please see {_totalMinted}.\n   */\n  function totalSupply() public view virtual override returns (uint256) {\n    // Counter underflow is impossible as _burnCounter cannot be incremented\n    // more than `_currentIndex - _startTokenId()` times.\n    unchecked {\n      return _currentIndex - _burnCounter - _startTokenId();\n    }\n  }\n\n  /**\n   * @dev Returns the total amount of tokens minted in the contract.\n   */\n  function _totalMinted() internal view virtual returns (uint256) {\n    // Counter underflow is impossible as `_currentIndex` does not decrement,\n    // and it is initialized to `_startTokenId()`.\n    unchecked {\n      return _currentIndex - _startTokenId();\n    }\n  }\n\n  /**\n   * @dev Returns the total number of tokens burned.\n   */\n  function _totalBurned() internal view virtual returns (uint256) {\n    return _burnCounter;\n  }\n\n  // =============================================================\n  //                    ADDRESS DATA OPERATIONS\n  // =============================================================\n\n  /**\n   * @dev Returns the number of tokens in `owner`'s account.\n   */\n  function balanceOf(address owner)\n    public\n    view\n    virtual\n    override\n    returns (uint256)\n  {\n    if (owner == address(0)) revert BalanceQueryForZeroAddress();\n    return _packedAddressData[owner] & _BITMASK_ADDRESS_DATA_ENTRY;\n  }\n\n  /**\n   * Returns the number of tokens minted by `owner`.\n   */\n  function _numberMinted(address owner) internal view returns (uint256) {\n    return\n      (_packedAddressData[owner] >> _BITPOS_NUMBER_MINTED) &\n      _BITMASK_ADDRESS_DATA_ENTRY;\n  }\n\n  /**\n   * Returns the number of tokens burned by or on behalf of `owner`.\n   */\n  function _numberBurned(address owner) internal view returns (uint256) {\n    return\n      (_packedAddressData[owner] >> _BITPOS_NUMBER_BURNED) &\n      _BITMASK_ADDRESS_DATA_ENTRY;\n  }\n\n  /**\n   * Returns the auxiliary data for `owner`. (e.g. number of whitelist mint slots used).\n   */\n  function _getAux(address owner) internal view returns (uint64) {\n    return uint64(_packedAddressData[owner] >> _BITPOS_AUX);\n  }\n\n  /**\n   * Sets the auxiliary data for `owner`. (e.g. number of whitelist mint slots used).\n   * If there are multiple variables, please pack them into a uint64.\n   */\n  function _setAux(address owner, uint64 aux) internal virtual {\n    uint256 packed = _packedAddressData[owner];\n    uint256 auxCasted;\n    // Cast `aux` with assembly to avoid redundant masking.\n    assembly {\n      auxCasted := aux\n    }\n    packed = (packed & _BITMASK_AUX_COMPLEMENT) | (auxCasted << _BITPOS_AUX);\n    _packedAddressData[owner] = packed;\n  }\n\n  // =============================================================\n  //                            IERC165\n  // =============================================================\n\n  /**\n   * @dev Returns true if this contract implements the interface defined by\n   * `interfaceId`. See the corresponding\n   * [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)\n   * to learn more about how these ids are created.\n   *\n   * This function call must use less than 30000 gas.\n   */\n  function supportsInterface(bytes4 interfaceId)\n    public\n    view\n    virtual\n    override\n    returns (bool)\n  {\n    // The interface IDs are constants representing the first 4 bytes\n    // of the XOR of all function selectors in the interface.\n    // See: [ERC165](https://eips.ethereum.org/EIPS/eip-165)\n    // (e.g. `bytes4(i.functionA.selector ^ i.functionB.selector ^ ...)`)\n    return\n      interfaceId == 0x01ffc9a7 || // ERC165 interface ID for ERC165.\n      interfaceId == 0x80ac58cd || // ERC165 interface ID for ERC721.\n      interfaceId == 0x5b5e139f; // ERC165 interface ID for ERC721Metadata.\n  }\n\n  // =============================================================\n  //                        IERC721Metadata\n  // =============================================================\n\n  /**\n   * @dev Returns the token collection name.\n   */\n  function name() public view virtual override returns (string memory) {\n    return _name;\n  }\n\n  /**\n   * @dev Returns the token collection symbol.\n   */\n  function symbol() public view virtual override returns (string memory) {\n    return _symbol;\n  }\n\n  /**\n   * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.\n   */\n  function tokenURI(uint256 tokenId)\n    public\n    view\n    virtual\n    override\n    returns (string memory)\n  {\n    if (!_exists(tokenId)) revert URIQueryForNonexistentToken();\n\n    string memory baseURI = _baseURI();\n    return\n      bytes(baseURI).length != 0\n        ? string(abi.encodePacked(baseURI, _toString(tokenId)))\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, it can be overridden in child contracts.\n   */\n  function _baseURI() internal view virtual returns (string memory) {\n    return \"\";\n  }\n\n  // =============================================================\n  //                     OWNERSHIPS OPERATIONS\n  // =============================================================\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)\n    public\n    view\n    virtual\n    override\n    returns (address)\n  {\n    return address(uint160(_packedOwnershipOf(tokenId)));\n  }\n\n  /**\n   * @dev Gas spent here starts off proportional to the maximum mint batch size.\n   * It gradually moves to O(1) as tokens get transferred around over time.\n   */\n  function _ownershipOf(uint256 tokenId)\n    internal\n    view\n    virtual\n    returns (TokenOwnership memory)\n  {\n    return _unpackedOwnership(_packedOwnershipOf(tokenId));\n  }\n\n  /**\n   * @dev Returns the unpacked `TokenOwnership` struct at `index`.\n   */\n  function _ownershipAt(uint256 index)\n    internal\n    view\n    virtual\n    returns (TokenOwnership memory)\n  {\n    return _unpackedOwnership(_packedOwnerships[index]);\n  }\n\n  /**\n   * @dev Initializes the ownership slot minted at `index` for efficiency purposes.\n   */\n  function _initializeOwnershipAt(uint256 index) internal virtual {\n    if (_packedOwnerships[index] == 0) {\n      _packedOwnerships[index] = _packedOwnershipOf(index);\n    }\n  }\n\n  /**\n   * Returns the packed ownership data of `tokenId`.\n   */\n  function _packedOwnershipOf(uint256 tokenId) private view returns (uint256) {\n    uint256 curr = tokenId;\n\n    unchecked {\n      if (_startTokenId() <= curr)\n        if (curr < _currentIndex) {\n          uint256 packed = _packedOwnerships[curr];\n          // If not burned.\n          if (packed & _BITMASK_BURNED == 0) {\n            // Invariant:\n            // There will always be an initialized ownership slot\n            // (i.e. `ownership.addr != address(0) && ownership.burned == false`)\n            // before an unintialized ownership slot\n            // (i.e. `ownership.addr == address(0) && ownership.burned == false`)\n            // Hence, `curr` will not underflow.\n            //\n            // We can directly compare the packed value.\n            // If the address is zero, packed will be zero.\n            while (packed == 0) {\n              packed = _packedOwnerships[--curr];\n            }\n            return packed;\n          }\n        }\n    }\n    revert OwnerQueryForNonexistentToken();\n  }\n\n  /**\n   * @dev Returns the unpacked `TokenOwnership` struct from `packed`.\n   */\n  function _unpackedOwnership(uint256 packed)\n    private\n    pure\n    returns (TokenOwnership memory ownership)\n  {\n    ownership.addr = address(uint160(packed));\n    ownership.startTimestamp = uint64(packed >> _BITPOS_START_TIMESTAMP);\n    ownership.burned = packed & _BITMASK_BURNED != 0;\n    ownership.extraData = uint24(packed >> _BITPOS_EXTRA_DATA);\n  }\n\n  /**\n   * @dev Packs ownership data into a single uint256.\n   */\n  function _packOwnershipData(address owner, uint256 flags)\n    private\n    view\n    returns (uint256 result)\n  {\n    assembly {\n      // Mask `owner` to the lower 160 bits, in case the upper bits somehow aren't clean.\n      owner := and(owner, _BITMASK_ADDRESS)\n      // `owner | (block.timestamp << _BITPOS_START_TIMESTAMP) | flags`.\n      result := or(owner, or(shl(_BITPOS_START_TIMESTAMP, timestamp()), flags))\n    }\n  }\n\n  /**\n   * @dev Returns the `nextInitialized` flag set if `quantity` equals 1.\n   */\n  function _nextInitializedFlag(uint256 quantity)\n    private\n    pure\n    returns (uint256 result)\n  {\n    // For branchless setting of the `nextInitialized` flag.\n    assembly {\n      // `(quantity == 1) << _BITPOS_NEXT_INITIALIZED`.\n      result := shl(_BITPOS_NEXT_INITIALIZED, eq(quantity, 1))\n    }\n  }\n\n  // =============================================================\n  //                      APPROVAL OPERATIONS\n  // =============================================================\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\n   * 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) public virtual override {\n    address owner = ownerOf(tokenId);\n\n    if (_msgSenderERC721A() != owner)\n      if (!isApprovedForAll(owner, _msgSenderERC721A())) {\n        revert ApprovalCallerNotOwnerNorApproved();\n      }\n\n    _tokenApprovals[tokenId].value = to;\n    emit Approval(owner, to, tokenId);\n  }\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)\n    public\n    view\n    virtual\n    override\n    returns (address)\n  {\n    if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();\n\n    return _tokenApprovals[tokenId].value;\n  }\n\n  /**\n   * @dev Approve or remove `operator` as an operator for the caller.\n   * Operators can call {transferFrom} or {safeTransferFrom}\n   * 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)\n    public\n    virtual\n    override\n  {\n    if (operator == _msgSenderERC721A()) revert ApproveToCaller();\n\n    _operatorApprovals[_msgSenderERC721A()][operator] = approved;\n    emit ApprovalForAll(_msgSenderERC721A(), operator, approved);\n  }\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)\n    public\n    view\n    virtual\n    override\n    returns (bool)\n  {\n    return _operatorApprovals[owner][operator];\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. See {_mint}.\n   */\n  function _exists(uint256 tokenId) internal view virtual returns (bool) {\n    return\n      _startTokenId() <= tokenId &&\n      tokenId < _currentIndex && // If within bounds,\n      _packedOwnerships[tokenId] & _BITMASK_BURNED == 0; // and not burned.\n  }\n\n  /**\n   * @dev Returns whether `msgSender` is equal to `approvedAddress` or `owner`.\n   */\n  function _isSenderApprovedOrOwner(\n    address approvedAddress,\n    address owner,\n    address msgSender\n  ) private pure returns (bool result) {\n    assembly {\n      // Mask `owner` to the lower 160 bits, in case the upper bits somehow aren't clean.\n      owner := and(owner, _BITMASK_ADDRESS)\n      // Mask `msgSender` to the lower 160 bits, in case the upper bits somehow aren't clean.\n      msgSender := and(msgSender, _BITMASK_ADDRESS)\n      // `msgSender == owner || msgSender == approvedAddress`.\n      result := or(eq(msgSender, owner), eq(msgSender, approvedAddress))\n    }\n  }\n\n  /**\n   * @dev Returns the storage slot and value for the approved address of `tokenId`.\n   */\n  function _getApprovedSlotAndAddress(uint256 tokenId)\n    private\n    view\n    returns (uint256 approvedAddressSlot, address approvedAddress)\n  {\n    TokenApprovalRef storage tokenApproval = _tokenApprovals[tokenId];\n    // The following is equivalent to `approvedAddress = _tokenApprovals[tokenId]`.\n    assembly {\n      approvedAddressSlot := tokenApproval.slot\n      approvedAddress := sload(approvedAddressSlot)\n    }\n  }\n\n  // =============================================================\n  //                      TRANSFER OPERATIONS\n  // =============================================================\n\n  /**\n   * @dev Transfers `tokenId` 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 be owned by `from`.\n   * - If the caller is not `from`, it must be approved to move this token\n   * 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  ) public virtual override {\n    uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);\n\n    if (address(uint160(prevOwnershipPacked)) != from)\n      revert TransferFromIncorrectOwner();\n\n    (\n      uint256 approvedAddressSlot,\n      address approvedAddress\n    ) = _getApprovedSlotAndAddress(tokenId);\n\n    // The nested ifs save around 20+ gas over a compound boolean condition.\n    if (!_isSenderApprovedOrOwner(approvedAddress, from, _msgSenderERC721A()))\n      if (!isApprovedForAll(from, _msgSenderERC721A()))\n        revert TransferCallerNotOwnerNorApproved();\n\n    if (to == address(0)) revert TransferToZeroAddress();\n\n    _beforeTokenTransfers(from, to, tokenId, 1);\n\n    // Clear approvals from the previous owner.\n    assembly {\n      if approvedAddress {\n        // This is equivalent to `delete _tokenApprovals[tokenId]`.\n        sstore(approvedAddressSlot, 0)\n      }\n    }\n\n    // Underflow of the sender's balance is impossible because we check for\n    // ownership above and the recipient's balance can't realistically overflow.\n    // Counter overflow is incredibly unrealistic as `tokenId` would have to be 2**256.\n    unchecked {\n      // We can directly increment and decrement the balances.\n      --_packedAddressData[from]; // Updates: `balance -= 1`.\n      ++_packedAddressData[to]; // Updates: `balance += 1`.\n\n      // Updates:\n      // - `address` to the next owner.\n      // - `startTimestamp` to the timestamp of transfering.\n      // - `burned` to `false`.\n      // - `nextInitialized` to `true`.\n      _packedOwnerships[tokenId] = _packOwnershipData(\n        to,\n        _BITMASK_NEXT_INITIALIZED |\n          _nextExtraData(from, to, prevOwnershipPacked)\n      );\n\n      // If the next slot may not have been initialized (i.e. `nextInitialized == false`) .\n      if (prevOwnershipPacked & _BITMASK_NEXT_INITIALIZED == 0) {\n        uint256 nextTokenId = tokenId + 1;\n        // If the next slot's address is zero and not burned (i.e. packed value is zero).\n        if (_packedOwnerships[nextTokenId] == 0) {\n          // If the next slot is within bounds.\n          if (nextTokenId != _currentIndex) {\n            // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.\n            _packedOwnerships[nextTokenId] = prevOwnershipPacked;\n          }\n        }\n      }\n    }\n\n    emit Transfer(from, to, tokenId);\n    _afterTokenTransfers(from, to, tokenId, 1);\n  }\n\n  /**\n   * @dev Equivalent to `safeTransferFrom(from, to, tokenId, '')`.\n   */\n  function safeTransferFrom(\n    address from,\n    address to,\n    uint256 tokenId\n  ) public virtual override {\n    safeTransferFrom(from, to, tokenId, \"\");\n  }\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\n   * by either {approve} or {setApprovalForAll}.\n   * - If `to` refers to a smart contract, it must implement\n   * {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 memory _data\n  ) public virtual override {\n    transferFrom(from, to, tokenId);\n    if (to.code.length != 0)\n      if (!_checkContractOnERC721Received(from, to, tokenId, _data)) {\n        revert TransferToNonERC721ReceiverImplementer();\n      }\n  }\n\n  /**\n   * @dev Hook that is called before a set of serially-ordered token IDs\n   * are about to be transferred. This includes minting.\n   * And also called before burning one token.\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   * - When `to` is zero, `tokenId` will be burned by `from`.\n   * - `from` and `to` are never both zero.\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\n   * have been transferred. This includes minting.\n   * And also called after one token has been burned.\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` has been\n   * transferred to `to`.\n   * - When `from` is zero, `tokenId` has been minted for `to`.\n   * - When `to` is zero, `tokenId` has been burned by `from`.\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  /**\n   * @dev Private function to invoke {IERC721Receiver-onERC721Received} on a target contract.\n   *\n   * `from` - Previous owner of the given token ID.\n   * `to` - Target address that will receive the token.\n   * `tokenId` - Token ID to be transferred.\n   * `_data` - Optional data to send along with the call.\n   *\n   * Returns whether the call correctly returned the expected magic value.\n   */\n  function _checkContractOnERC721Received(\n    address from,\n    address to,\n    uint256 tokenId,\n    bytes memory _data\n  ) private returns (bool) {\n    try\n      ERC721A__IERC721Receiver(to).onERC721Received(\n        _msgSenderERC721A(),\n        from,\n        tokenId,\n        _data\n      )\n    returns (bytes4 retval) {\n      return retval == ERC721A__IERC721Receiver(to).onERC721Received.selector;\n    } catch (bytes memory reason) {\n      if (reason.length == 0) {\n        revert TransferToNonERC721ReceiverImplementer();\n      } else {\n        assembly {\n          revert(add(32, reason), mload(reason))\n        }\n      }\n    }\n  }\n\n  // =============================================================\n  //                        MINT OPERATIONS\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` must be greater than 0.\n   *\n   * Emits a {Transfer} event for each mint.\n   */\n  function _mint(address to, uint256 quantity) internal virtual {\n    uint256 startTokenId = _currentIndex;\n    if (quantity == 0) revert MintZeroQuantity();\n\n    _beforeTokenTransfers(address(0), to, startTokenId, quantity);\n\n    // Overflows are incredibly unrealistic.\n    // `balance` and `numberMinted` have a maximum limit of 2**64.\n    // `tokenId` has a maximum limit of 2**256.\n    unchecked {\n      // Updates:\n      // - `balance += quantity`.\n      // - `numberMinted += quantity`.\n      //\n      // We can directly add to the `balance` and `numberMinted`.\n      _packedAddressData[to] += quantity * ((1 << _BITPOS_NUMBER_MINTED) | 1);\n\n      // Updates:\n      // - `address` to the owner.\n      // - `startTimestamp` to the timestamp of minting.\n      // - `burned` to `false`.\n      // - `nextInitialized` to `quantity == 1`.\n      _packedOwnerships[startTokenId] = _packOwnershipData(\n        to,\n        _nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)\n      );\n\n      uint256 toMasked;\n      uint256 end = startTokenId + quantity;\n\n      // Use assembly to loop and emit the `Transfer` event for gas savings.\n      assembly {\n        // Mask `to` to the lower 160 bits, in case the upper bits somehow aren't clean.\n        toMasked := and(to, _BITMASK_ADDRESS)\n        // Emit the `Transfer` event.\n        log4(\n          0, // Start of data (0, since no data).\n          0, // End of data (0, since no data).\n          _TRANSFER_EVENT_SIGNATURE, // Signature.\n          0, // `address(0)`.\n          toMasked, // `to`.\n          startTokenId // `tokenId`.\n        )\n\n        for {\n          let tokenId := add(startTokenId, 1)\n        } iszero(eq(tokenId, end)) {\n          tokenId := add(tokenId, 1)\n        } {\n          // Emit the `Transfer` event. Similar to above.\n          log4(0, 0, _TRANSFER_EVENT_SIGNATURE, 0, toMasked, tokenId)\n        }\n      }\n      if (toMasked == 0) revert MintToZeroAddress();\n\n      _currentIndex = end;\n    }\n    _afterTokenTransfers(address(0), to, startTokenId, quantity);\n  }\n\n  /**\n   * @dev Mints `quantity` tokens and transfers them to `to`.\n   *\n   * This function is intended for efficient minting only during contract creation.\n   *\n   * It emits only one {ConsecutiveTransfer} as defined in\n   * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309),\n   * instead of a sequence of {Transfer} event(s).\n   *\n   * Calling this function outside of contract creation WILL make your contract\n   * non-compliant with the ERC721 standard.\n   * For full ERC721 compliance, substituting ERC721 {Transfer} event(s) with the ERC2309\n   * {ConsecutiveTransfer} event is only permissible during contract creation.\n   *\n   * Requirements:\n   *\n   * - `to` cannot be the zero address.\n   * - `quantity` must be greater than 0.\n   *\n   * Emits a {ConsecutiveTransfer} event.\n   */\n  function _mintERC2309(address to, uint256 quantity) internal virtual {\n    uint256 startTokenId = _currentIndex;\n    if (to == address(0)) revert MintToZeroAddress();\n    if (quantity == 0) revert MintZeroQuantity();\n    if (quantity > _MAX_MINT_ERC2309_QUANTITY_LIMIT)\n      revert MintERC2309QuantityExceedsLimit();\n\n    _beforeTokenTransfers(address(0), to, startTokenId, quantity);\n\n    // Overflows are unrealistic due to the above check for `quantity` to be below the limit.\n    unchecked {\n      // Updates:\n      // - `balance += quantity`.\n      // - `numberMinted += quantity`.\n      //\n      // We can directly add to the `balance` and `numberMinted`.\n      _packedAddressData[to] += quantity * ((1 << _BITPOS_NUMBER_MINTED) | 1);\n\n      // Updates:\n      // - `address` to the owner.\n      // - `startTimestamp` to the timestamp of minting.\n      // - `burned` to `false`.\n      // - `nextInitialized` to `quantity == 1`.\n      _packedOwnerships[startTokenId] = _packOwnershipData(\n        to,\n        _nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)\n      );\n\n      emit ConsecutiveTransfer(\n        startTokenId,\n        startTokenId + quantity - 1,\n        address(0),\n        to\n      );\n\n      _currentIndex = startTokenId + quantity;\n    }\n    _afterTokenTransfers(address(0), to, startTokenId, quantity);\n  }\n\n  /**\n   * @dev Safely mints `quantity` tokens and transfers them to `to`.\n   *\n   * Requirements:\n   *\n   * - If `to` refers to a smart contract, it must implement\n   * {IERC721Receiver-onERC721Received}, which is called for each safe transfer.\n   * - `quantity` must be greater than 0.\n   *\n   * See {_mint}.\n   *\n   * Emits a {Transfer} event for each mint.\n   */\n  function _safeMint(\n    address to,\n    uint256 quantity,\n    bytes memory _data\n  ) internal virtual {\n    _mint(to, quantity);\n\n    unchecked {\n      if (to.code.length != 0) {\n        uint256 end = _currentIndex;\n        uint256 index = end - quantity;\n        do {\n          if (!_checkContractOnERC721Received(address(0), to, index++, _data)) {\n            revert TransferToNonERC721ReceiverImplementer();\n          }\n        } while (index < end);\n        // Reentrancy protection.\n        if (_currentIndex != end) revert();\n      }\n    }\n  }\n\n  /**\n   * @dev Equivalent to `_safeMint(to, quantity, '')`.\n   */\n  function _safeMint(address to, uint256 quantity) internal virtual {\n    _safeMint(to, quantity, \"\");\n  }\n\n  // =============================================================\n  //                        BURN OPERATIONS\n  // =============================================================\n\n  /**\n   * @dev Equivalent to `_burn(tokenId, false)`.\n   */\n  function _burn(uint256 tokenId) internal virtual {\n    _burn(tokenId, false);\n  }\n\n  /**\n   * @dev Destroys `tokenId`.\n   * The approval is cleared when the token is burned.\n   *\n   * Requirements:\n   *\n   * - `tokenId` must exist.\n   *\n   * Emits a {Transfer} event.\n   */\n  function _burn(uint256 tokenId, bool approvalCheck) internal virtual {\n    uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);\n\n    address from = address(uint160(prevOwnershipPacked));\n\n    (\n      uint256 approvedAddressSlot,\n      address approvedAddress\n    ) = _getApprovedSlotAndAddress(tokenId);\n\n    if (approvalCheck) {\n      // The nested ifs save around 20+ gas over a compound boolean condition.\n      if (!_isSenderApprovedOrOwner(approvedAddress, from, _msgSenderERC721A()))\n        if (!isApprovedForAll(from, _msgSenderERC721A()))\n          revert TransferCallerNotOwnerNorApproved();\n    }\n\n    _beforeTokenTransfers(from, address(0), tokenId, 1);\n\n    // Clear approvals from the previous owner.\n    assembly {\n      if approvedAddress {\n        // This is equivalent to `delete _tokenApprovals[tokenId]`.\n        sstore(approvedAddressSlot, 0)\n      }\n    }\n\n    // Underflow of the sender's balance is impossible because we check for\n    // ownership above and the recipient's balance can't realistically overflow.\n    // Counter overflow is incredibly unrealistic as `tokenId` would have to be 2**256.\n    unchecked {\n      // Updates:\n      // - `balance -= 1`.\n      // - `numberBurned += 1`.\n      //\n      // We can directly decrement the balance, and increment the number burned.\n      // This is equivalent to `packed -= 1; packed += 1 << _BITPOS_NUMBER_BURNED;`.\n      _packedAddressData[from] += (1 << _BITPOS_NUMBER_BURNED) - 1;\n\n      // Updates:\n      // - `address` to the last owner.\n      // - `startTimestamp` to the timestamp of burning.\n      // - `burned` to `true`.\n      // - `nextInitialized` to `true`.\n      _packedOwnerships[tokenId] = _packOwnershipData(\n        from,\n        (_BITMASK_BURNED | _BITMASK_NEXT_INITIALIZED) |\n          _nextExtraData(from, address(0), prevOwnershipPacked)\n      );\n\n      // If the next slot may not have been initialized (i.e. `nextInitialized == false`) .\n      if (prevOwnershipPacked & _BITMASK_NEXT_INITIALIZED == 0) {\n        uint256 nextTokenId = tokenId + 1;\n        // If the next slot's address is zero and not burned (i.e. packed value is zero).\n        if (_packedOwnerships[nextTokenId] == 0) {\n          // If the next slot is within bounds.\n          if (nextTokenId != _currentIndex) {\n            // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.\n            _packedOwnerships[nextTokenId] = prevOwnershipPacked;\n          }\n        }\n      }\n    }\n\n    emit Transfer(from, address(0), tokenId);\n    _afterTokenTransfers(from, address(0), tokenId, 1);\n\n    // Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.\n    unchecked {\n      _burnCounter++;\n    }\n  }\n\n  // =============================================================\n  //                     EXTRA DATA OPERATIONS\n  // =============================================================\n\n  /**\n   * @dev Directly sets the extra data for the ownership data `index`.\n   */\n  function _setExtraDataAt(uint256 index, uint24 extraData) internal virtual {\n    uint256 packed = _packedOwnerships[index];\n    if (packed == 0) revert OwnershipNotInitializedForExtraData();\n    uint256 extraDataCasted;\n    // Cast `extraData` with assembly to avoid redundant masking.\n    assembly {\n      extraDataCasted := extraData\n    }\n    packed =\n      (packed & _BITMASK_EXTRA_DATA_COMPLEMENT) |\n      (extraDataCasted << _BITPOS_EXTRA_DATA);\n    _packedOwnerships[index] = packed;\n  }\n\n  /**\n   * @dev Called during each token transfer to set the 24bit `extraData` field.\n   * Intended to be overridden by the cosumer contract.\n   *\n   * `previousExtraData` - the value of `extraData` before transfer.\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   * - When `to` is zero, `tokenId` will be burned by `from`.\n   * - `from` and `to` are never both zero.\n   */\n  function _extraData(\n    address from,\n    address to,\n    uint24 previousExtraData\n  ) internal view virtual returns (uint24) {}\n\n  /**\n   * @dev Returns the next extra data for the packed ownership data.\n   * The returned result is shifted into position.\n   */\n  function _nextExtraData(\n    address from,\n    address to,\n    uint256 prevOwnershipPacked\n  ) private view returns (uint256) {\n    uint24 extraData = uint24(prevOwnershipPacked >> _BITPOS_EXTRA_DATA);\n    return uint256(_extraData(from, to, extraData)) << _BITPOS_EXTRA_DATA;\n  }\n\n  // =============================================================\n  //                       OTHER OPERATIONS\n  // =============================================================\n\n  /**\n   * @dev Returns the message sender (defaults to `msg.sender`).\n   *\n   * If you are writing GSN compatible contracts, you need to override this function.\n   */\n  function _msgSenderERC721A() internal view virtual returns (address) {\n    return msg.sender;\n  }\n\n  /**\n   * @dev Converts a uint256 to its ASCII string decimal representation.\n   */\n  function _toString(uint256 value)\n    internal\n    pure\n    virtual\n    returns (string memory str)\n  {\n    assembly {\n      // The maximum value of a uint256 contains 78 digits (1 byte per digit),\n      // but we allocate 0x80 bytes to keep the free memory pointer 32-byte word aliged.\n      // We will need 1 32-byte word to store the length,\n      // and 3 32-byte words to store a maximum of 78 digits. Total: 0x20 + 3 * 0x20 = 0x80.\n      str := add(mload(0x40), 0x80)\n      // Update the free memory pointer to allocate.\n      mstore(0x40, str)\n\n      // Cache the end of the memory to calculate the length later.\n      let end := str\n\n      // We write the string from rightmost digit to leftmost digit.\n      // The following is essentially a do-while loop that also handles the zero case.\n      // prettier-ignore\n      for { let temp := value } 1 {} {\n                str := sub(str, 1)\n                // Write the character to the pointer.\n                // The ASCII index of the '0' character is 48.\n                mstore8(str, add(48, mod(temp, 10)))\n                // Keep dividing `temp` until zero.\n                temp := div(temp, 10)\n                // prettier-ignore\n                if iszero(temp) { break }\n            }\n\n      let length := sub(end, str)\n      // Move the pointer 32 bytes leftwards to make room for the length.\n      str := sub(str, 0x20)\n      // Store the length.\n      mstore(str, length)\n    }\n  }\n}\n"
    },
    "contracts/interfaces/IMetadataRenderer.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface IMetadataRenderer {\n  function tokenURI(uint256) external view returns (string memory);\n\n  function contractURI() external view returns (string memory);\n\n  function initializeWithData(bytes memory initData) external;\n\n  /// @notice Storage for token edition information\n  struct TokenEditionInfo {\n    string description;\n    string imageURI;\n    string animationURI;\n  }\n}\n"
    },
    "@openzeppelin/contracts/proxy/utils/Initializable.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../../utils/Address.sol\";\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\n * reused. This mechanism prevents re-execution of each \"step\" but allows the creation of new initialization steps in\n * case an upgrade adds a module that needs to be initialized.\n *\n * For example:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * contract MyToken is ERC20Upgradeable {\n *     function initialize() initializer public {\n *         __ERC20_init(\"MyToken\", \"MTK\");\n *     }\n * }\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\n *     function initializeV2() reinitializer(2) public {\n *         __ERC20Permit_init(\"MyToken\");\n *     }\n * }\n * ```\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n *\n * [CAUTION]\n * ====\n * Avoid leaving a contract uninitialized.\n *\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * /// @custom:oz-upgrades-unsafe-allow constructor\n * constructor() {\n *     _disableInitializers();\n * }\n * ```\n * ====\n */\nabstract contract Initializable {\n    /**\n     * @dev Indicates that the contract has been initialized.\n     * @custom:oz-retyped-from bool\n     */\n    uint8 private _initialized;\n\n    /**\n     * @dev Indicates that the contract is in the process of being initialized.\n     */\n    bool private _initializing;\n\n    /**\n     * @dev Triggered when the contract has been initialized or reinitialized.\n     */\n    event Initialized(uint8 version);\n\n    /**\n     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\n     * `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`.\n     */\n    modifier initializer() {\n        bool isTopLevelCall = !_initializing;\n        require(\n            (isTopLevelCall && _initialized < 1) || (!Address.isContract(address(this)) && _initialized == 1),\n            \"Initializable: contract is already initialized\"\n        );\n        _initialized = 1;\n        if (isTopLevelCall) {\n            _initializing = true;\n        }\n        _;\n        if (isTopLevelCall) {\n            _initializing = false;\n            emit Initialized(1);\n        }\n    }\n\n    /**\n     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\n     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\n     * used to initialize parent contracts.\n     *\n     * `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original\n     * initialization step. This is essential to configure modules that are added through upgrades and that require\n     * initialization.\n     *\n     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\n     * a contract, executing them in the right order is up to the developer or operator.\n     */\n    modifier reinitializer(uint8 version) {\n        require(!_initializing && _initialized < version, \"Initializable: contract is already initialized\");\n        _initialized = version;\n        _initializing = true;\n        _;\n        _initializing = false;\n        emit Initialized(version);\n    }\n\n    /**\n     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\n     * {initializer} and {reinitializer} modifiers, directly or indirectly.\n     */\n    modifier onlyInitializing() {\n        require(_initializing, \"Initializable: contract is not initializing\");\n        _;\n    }\n\n    /**\n     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\n     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\n     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\n     * through proxies.\n     */\n    function _disableInitializers() internal virtual {\n        require(!_initializing, \"Initializable: contract is initializing\");\n        if (_initialized < type(uint8).max) {\n            _initialized = type(uint8).max;\n            emit Initialized(type(uint8).max);\n        }\n    }\n}\n"
    },
    "@openzeppelin/contracts/access/Ownable.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (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 Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\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 the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\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"
    },
    "contracts/storage/EditionConfig.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nstruct EditionConfig {\n  string name;\n  string symbol;\n  bool hasAdjustableCap;\n  uint256 maxTokens;\n  uint256 tokenPrice;\n  uint256 maxTokenPurchase;\n  bytes32 presaleMerkleRoot;\n  uint256 presaleStart;\n  uint256 presaleEnd;\n  uint256 saleStart;\n  uint256 saleEnd;\n  uint256 royaltyBPS;\n}\n"
    },
    "contracts/storage/MetadataConfig.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nstruct MetadataConfig {\n  string contractURI;\n  string metadataURI;\n  bytes metadataRendererInit;\n  address parentIP;\n}\n"
    },
    "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/cryptography/MerkleProof.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev These functions deal with verification of Merkle Tree 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 *\n * WARNING: You should avoid using leaf values that are 64 bytes long prior to\n * hashing, or use a hash function other than keccak256 for hashing leaves.\n * This is because the concatenation of a sorted pair of internal nodes in\n * the merkle tree could be reinterpreted as a leaf value.\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 Calldata version of {verify}\n     *\n     * _Available since v4.7._\n     */\n    function verifyCalldata(\n        bytes32[] calldata proof,\n        bytes32 root,\n        bytes32 leaf\n    ) internal pure returns (bool) {\n        return processProofCalldata(proof, leaf) == root;\n    }\n\n    /**\n     * @dev Returns the rebuilt hash obtained by traversing a Merkle 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            computedHash = _hashPair(computedHash, proof[i]);\n        }\n        return computedHash;\n    }\n\n    /**\n     * @dev Calldata version of {processProof}\n     *\n     * _Available since v4.7._\n     */\n    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {\n        bytes32 computedHash = leaf;\n        for (uint256 i = 0; i < proof.length; i++) {\n            computedHash = _hashPair(computedHash, proof[i]);\n        }\n        return computedHash;\n    }\n\n    /**\n     * @dev Returns true if the `leaves` can be proved to be a part of a Merkle tree defined by\n     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.\n     *\n     * _Available since v4.7._\n     */\n    function multiProofVerify(\n        bytes32[] memory proof,\n        bool[] memory proofFlags,\n        bytes32 root,\n        bytes32[] memory leaves\n    ) internal pure returns (bool) {\n        return processMultiProof(proof, proofFlags, leaves) == root;\n    }\n\n    /**\n     * @dev Calldata version of {multiProofVerify}\n     *\n     * _Available since v4.7._\n     */\n    function multiProofVerifyCalldata(\n        bytes32[] calldata proof,\n        bool[] calldata proofFlags,\n        bytes32 root,\n        bytes32[] memory leaves\n    ) internal pure returns (bool) {\n        return processMultiProofCalldata(proof, proofFlags, leaves) == root;\n    }\n\n    /**\n     * @dev Returns the root of a tree reconstructed from `leaves` and the sibling nodes in `proof`,\n     * consuming from one or the other at each step according to the instructions given by\n     * `proofFlags`.\n     *\n     * _Available since v4.7._\n     */\n    function processMultiProof(\n        bytes32[] memory proof,\n        bool[] memory proofFlags,\n        bytes32[] memory leaves\n    ) internal pure returns (bytes32 merkleRoot) {\n        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by\n        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the\n        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of\n        // the merkle tree.\n        uint256 leavesLen = leaves.length;\n        uint256 totalHashes = proofFlags.length;\n\n        // Check proof validity.\n        require(leavesLen + proof.length - 1 == totalHashes, \"MerkleProof: invalid multiproof\");\n\n        // The xxxPos values are \"pointers\" to the next value to consume in each array. All accesses are done using\n        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's \"pop\".\n        bytes32[] memory hashes = new bytes32[](totalHashes);\n        uint256 leafPos = 0;\n        uint256 hashPos = 0;\n        uint256 proofPos = 0;\n        // At each step, we compute the next hash using two values:\n        // - a value from the \"main queue\". If not all leaves have been consumed, we get the next leaf, otherwise we\n        //   get the next hash.\n        // - depending on the flag, either another value for the \"main queue\" (merging branches) or an element from the\n        //   `proof` array.\n        for (uint256 i = 0; i < totalHashes; i++) {\n            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];\n            bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];\n            hashes[i] = _hashPair(a, b);\n        }\n\n        if (totalHashes > 0) {\n            return hashes[totalHashes - 1];\n        } else if (leavesLen > 0) {\n            return leaves[0];\n        } else {\n            return proof[0];\n        }\n    }\n\n    /**\n     * @dev Calldata version of {processMultiProof}\n     *\n     * _Available since v4.7._\n     */\n    function processMultiProofCalldata(\n        bytes32[] calldata proof,\n        bool[] calldata proofFlags,\n        bytes32[] memory leaves\n    ) internal pure returns (bytes32 merkleRoot) {\n        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by\n        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the\n        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of\n        // the merkle tree.\n        uint256 leavesLen = leaves.length;\n        uint256 totalHashes = proofFlags.length;\n\n        // Check proof validity.\n        require(leavesLen + proof.length - 1 == totalHashes, \"MerkleProof: invalid multiproof\");\n\n        // The xxxPos values are \"pointers\" to the next value to consume in each array. All accesses are done using\n        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's \"pop\".\n        bytes32[] memory hashes = new bytes32[](totalHashes);\n        uint256 leafPos = 0;\n        uint256 hashPos = 0;\n        uint256 proofPos = 0;\n        // At each step, we compute the next hash using two values:\n        // - a value from the \"main queue\". If not all leaves have been consumed, we get the next leaf, otherwise we\n        //   get the next hash.\n        // - depending on the flag, either another value for the \"main queue\" (merging branches) or an element from the\n        //   `proof` array.\n        for (uint256 i = 0; i < totalHashes; i++) {\n            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];\n            bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];\n            hashes[i] = _hashPair(a, b);\n        }\n\n        if (totalHashes > 0) {\n            return hashes[totalHashes - 1];\n        } else if (leavesLen > 0) {\n            return leaves[0];\n        } else {\n            return proof[0];\n        }\n    }\n\n    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {\n        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);\n    }\n\n    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x00, a)\n            mstore(0x20, b)\n            value := keccak256(0x00, 0x40)\n        }\n    }\n}\n"
    },
    "contracts/storage/DCNT721AStorage.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport './TokenGateConfig.sol';\n\ncontract DCNT721AStorage {\n  /// @notice token gating\n  TokenGateConfig public tokenGateConfig;\n}"
    },
    "contracts/utils/Splits.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\npragma solidity ^0.8;\n\nimport {ERC20} from \"solmate/src/tokens/ERC20.sol\";\nimport \"../splits/interfaces/ISplitMain.sol\";\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\n\nabstract contract Splits is Ownable {\n  function _getSplitMain() internal virtual returns (address);\n\n  function _getSplitWallet() internal virtual returns (address);\n\n  function _setSplitWallet(address _splitWallet) internal virtual;\n\n  function createSplit(\n    address[] calldata accounts,\n    uint32[] calldata percentAllocations,\n    uint32 distributorFee\n  ) public virtual onlyOwner {\n    require(_getSplitMain() != address(0), 'SplitMain not set');\n    require(_getSplitWallet() == address(0), \"Split already created\");\n    address splitAddress = ISplitMain(_getSplitMain()).createSplit(\n      accounts,\n      percentAllocations,\n      distributorFee,\n      msg.sender\n    );\n    _setSplitWallet(splitAddress);\n  }\n\n  function distributeETH(\n    address[] calldata accounts,\n    uint32[] calldata percentAllocations,\n    uint32 distributorFee,\n    address distributorAddress\n  ) public virtual requireSplit {\n    _transferETHToSplit();\n    ISplitMain(_getSplitMain()).distributeETH(\n      _getSplitWallet(),\n      accounts,\n      percentAllocations,\n      distributorFee,\n      distributorAddress\n    );\n  }\n\n  function distributeERC20(\n    ERC20 token,\n    address[] calldata accounts,\n    uint32[] calldata percentAllocations,\n    uint32 distributorFee,\n    address distributorAddress\n  ) public virtual requireSplit {\n    _transferERC20ToSplit(token);\n    ISplitMain(_getSplitMain()).distributeERC20(\n      _getSplitWallet(),\n      token,\n      accounts,\n      percentAllocations,\n      distributorFee,\n      distributorAddress\n    );\n  }\n\n  function distributeAndWithdraw(\n    address account,\n    uint256 withdrawETH,\n    ERC20[] memory tokens,\n    address[] calldata accounts,\n    uint32[] calldata percentAllocations,\n    uint32 distributorFee,\n    address distributorAddress\n  ) public virtual requireSplit {\n    if (withdrawETH != 0) {\n      distributeETH(\n        accounts,\n        percentAllocations,\n        distributorFee,\n        distributorAddress\n      );\n    }\n\n    for (uint256 i = 0; i < tokens.length; ++i) {\n      distributeERC20(\n        tokens[i],\n        accounts,\n        percentAllocations,\n        distributorFee,\n        distributorAddress\n      );\n    }\n\n    _withdraw(account, withdrawETH, tokens);\n  }\n\n  function transferToSplit(uint256 transferETH, ERC20[] memory tokens)\n    public\n    virtual\n    requireSplit\n  {\n    if (transferETH != 0) {\n      _transferETHToSplit();\n    }\n\n    for (uint256 i = 0; i < tokens.length; ++i) {\n      _transferERC20ToSplit(tokens[i]);\n    }\n  }\n\n  function _transferETHToSplit() internal virtual {\n    (bool success, ) = _getSplitWallet().call{value: address(this).balance}(\"\");\n    require(success, \"Could not transfer ETH to split\");\n  }\n\n  function _transferERC20ToSplit(ERC20 token) internal virtual {\n    uint256 balance = token.balanceOf(address(this));\n    token.transfer(_getSplitWallet(), balance);\n  }\n\n  function _withdraw(\n    address account,\n    uint256 withdrawETH,\n    ERC20[] memory tokens\n  ) internal virtual {\n    ISplitMain(_getSplitMain()).withdraw(\n      account,\n      withdrawETH,\n      tokens\n    );\n  }\n\n  modifier requireSplit() {\n    require(_getSplitWallet() != address(0), \"Split not created yet\");\n    _;\n  }\n}\n"
    },
    "contracts/interfaces/ITokenWithBalance.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface ITokenWithBalance {\n  function balanceOf(address owner) external\n    returns (uint256);\n}\n"
    },
    "erc721a/contracts/IERC721A.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// ERC721A Contracts v4.2.2\n// Creator: Chiru Labs\n\npragma solidity ^0.8.4;\n\n/**\n * @dev Interface of ERC721A.\n */\ninterface IERC721A {\n    /**\n     * The caller must own the token or be an approved operator.\n     */\n    error ApprovalCallerNotOwnerNorApproved();\n\n    /**\n     * The token does not exist.\n     */\n    error ApprovalQueryForNonexistentToken();\n\n    /**\n     * The caller cannot approve to their own address.\n     */\n    error ApproveToCaller();\n\n    /**\n     * Cannot query the balance for the zero address.\n     */\n    error BalanceQueryForZeroAddress();\n\n    /**\n     * Cannot mint to the zero address.\n     */\n    error MintToZeroAddress();\n\n    /**\n     * The quantity of tokens minted must be more than zero.\n     */\n    error MintZeroQuantity();\n\n    /**\n     * The token does not exist.\n     */\n    error OwnerQueryForNonexistentToken();\n\n    /**\n     * The caller must own the token or be an approved operator.\n     */\n    error TransferCallerNotOwnerNorApproved();\n\n    /**\n     * The token must be owned by `from`.\n     */\n    error TransferFromIncorrectOwner();\n\n    /**\n     * Cannot safely transfer to a contract that does not implement the\n     * ERC721Receiver interface.\n     */\n    error TransferToNonERC721ReceiverImplementer();\n\n    /**\n     * Cannot transfer to the zero address.\n     */\n    error TransferToZeroAddress();\n\n    /**\n     * The token does not exist.\n     */\n    error URIQueryForNonexistentToken();\n\n    /**\n     * The `quantity` minted with ERC2309 exceeds the safety limit.\n     */\n    error MintERC2309QuantityExceedsLimit();\n\n    /**\n     * The `extraData` cannot be set on an unintialized ownership slot.\n     */\n    error OwnershipNotInitializedForExtraData();\n\n    // =============================================================\n    //                            STRUCTS\n    // =============================================================\n\n    struct TokenOwnership {\n        // The address of the owner.\n        address addr;\n        // Stores the start time of ownership with minimal overhead for tokenomics.\n        uint64 startTimestamp;\n        // Whether the token has been burned.\n        bool burned;\n        // Arbitrary data similar to `startTimestamp` that can be set via {_extraData}.\n        uint24 extraData;\n    }\n\n    // =============================================================\n    //                         TOKEN COUNTERS\n    // =============================================================\n\n    /**\n     * @dev Returns the total number of tokens in existence.\n     * Burned tokens will reduce the count.\n     * To get the total number of tokens minted, please see {_totalMinted}.\n     */\n    function totalSupply() external view returns (uint256);\n\n    // =============================================================\n    //                            IERC165\n    // =============================================================\n\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n\n    // =============================================================\n    //                            IERC721\n    // =============================================================\n\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\n     * (`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`,\n     * checking first that contract recipients are aware of the ERC721 protocol\n     * 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\n     * this token by either {approve} or {setApprovalForAll}.\n     * - If `to` refers to a smart contract, it must implement\n     * {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    /**\n     * @dev Equivalent to `safeTransferFrom(from, to, tokenId, '')`.\n     */\n    function safeTransferFrom(\n        address from,\n        address to,\n        uint256 tokenId\n    ) external;\n\n    /**\n     * @dev Transfers `tokenId` from `from` to `to`.\n     *\n     * WARNING: Usage of this method is discouraged, use {safeTransferFrom}\n     * 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\n     * 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\n     * 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 Approve or remove `operator` as an operator for the caller.\n     * Operators can call {transferFrom} or {safeTransferFrom}\n     * 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 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 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    //                        IERC721Metadata\n    // =============================================================\n\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    // =============================================================\n    //                           IERC2309\n    // =============================================================\n\n    /**\n     * @dev Emitted when tokens in `fromTokenId` to `toTokenId`\n     * (inclusive) is transferred from `from` to `to`, as defined in the\n     * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309) standard.\n     *\n     * See {_mintERC2309} for more details.\n     */\n    event ConsecutiveTransfer(uint256 indexed fromTokenId, uint256 toTokenId, address indexed from, address indexed to);\n}\n"
    },
    "@openzeppelin/contracts/utils/Address.sol": {
      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\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     * [IMPORTANT]\n     * ====\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\n     *\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n     * constructor.\n     * ====\n     */\n    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize/address.code.length, which returns 0\n        // for contracts in construction, since the code is only stored at the end\n        // of the constructor execution.\n\n        return account.code.length > 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                /// @solidity memory-safe-assembly\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/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"
    },
    "contracts/storage/TokenGateConfig.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nenum SaleType {\n  ALL,\n  PRESALE,\n  PRIMARY\n}\n\nstruct TokenGateConfig {\n  address tokenAddress; \n  uint88 minBalance;\n  SaleType saleType;\n}\n"
    },
    "solmate/src/tokens/ERC20.sol": {
      "content": "// SPDX-License-Identifier: AGPL-3.0-only\npragma solidity >=0.8.0;\n\n/// @notice Modern and gas efficient ERC20 + EIP-2612 implementation.\n/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol)\n/// @author Modified from Uniswap (https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol)\n/// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it.\nabstract contract ERC20 {\n    /*//////////////////////////////////////////////////////////////\n                                 EVENTS\n    //////////////////////////////////////////////////////////////*/\n\n    event Transfer(address indexed from, address indexed to, uint256 amount);\n\n    event Approval(address indexed owner, address indexed spender, uint256 amount);\n\n    /*//////////////////////////////////////////////////////////////\n                            METADATA STORAGE\n    //////////////////////////////////////////////////////////////*/\n\n    string public name;\n\n    string public symbol;\n\n    uint8 public immutable decimals;\n\n    /*//////////////////////////////////////////////////////////////\n                              ERC20 STORAGE\n    //////////////////////////////////////////////////////////////*/\n\n    uint256 public totalSupply;\n\n    mapping(address => uint256) public balanceOf;\n\n    mapping(address => mapping(address => uint256)) public allowance;\n\n    /*//////////////////////////////////////////////////////////////\n                            EIP-2612 STORAGE\n    //////////////////////////////////////////////////////////////*/\n\n    uint256 internal immutable INITIAL_CHAIN_ID;\n\n    bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;\n\n    mapping(address => uint256) public nonces;\n\n    /*//////////////////////////////////////////////////////////////\n                               CONSTRUCTOR\n    //////////////////////////////////////////////////////////////*/\n\n    constructor(\n        string memory _name,\n        string memory _symbol,\n        uint8 _decimals\n    ) {\n        name = _name;\n        symbol = _symbol;\n        decimals = _decimals;\n\n        INITIAL_CHAIN_ID = block.chainid;\n        INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                               ERC20 LOGIC\n    //////////////////////////////////////////////////////////////*/\n\n    function approve(address spender, uint256 amount) public virtual returns (bool) {\n        allowance[msg.sender][spender] = amount;\n\n        emit Approval(msg.sender, spender, amount);\n\n        return true;\n    }\n\n    function transfer(address to, uint256 amount) public virtual returns (bool) {\n        balanceOf[msg.sender] -= amount;\n\n        // Cannot overflow because the sum of all user\n        // balances can't exceed the max uint256 value.\n        unchecked {\n            balanceOf[to] += amount;\n        }\n\n        emit Transfer(msg.sender, to, amount);\n\n        return true;\n    }\n\n    function transferFrom(\n        address from,\n        address to,\n        uint256 amount\n    ) public virtual returns (bool) {\n        uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals.\n\n        if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount;\n\n        balanceOf[from] -= amount;\n\n        // Cannot overflow because the sum of all user\n        // balances can't exceed the max uint256 value.\n        unchecked {\n            balanceOf[to] += amount;\n        }\n\n        emit Transfer(from, to, amount);\n\n        return true;\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                             EIP-2612 LOGIC\n    //////////////////////////////////////////////////////////////*/\n\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) public virtual {\n        require(deadline >= block.timestamp, \"PERMIT_DEADLINE_EXPIRED\");\n\n        // Unchecked because the only math done is incrementing\n        // the owner's nonce which cannot realistically overflow.\n        unchecked {\n            address recoveredAddress = ecrecover(\n                keccak256(\n                    abi.encodePacked(\n                        \"\\x19\\x01\",\n                        DOMAIN_SEPARATOR(),\n                        keccak256(\n                            abi.encode(\n                                keccak256(\n                                    \"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\"\n                                ),\n                                owner,\n                                spender,\n                                value,\n                                nonces[owner]++,\n                                deadline\n                            )\n                        )\n                    )\n                ),\n                v,\n                r,\n                s\n            );\n\n            require(recoveredAddress != address(0) && recoveredAddress == owner, \"INVALID_SIGNER\");\n\n            allowance[recoveredAddress][spender] = value;\n        }\n\n        emit Approval(owner, spender, value);\n    }\n\n    function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {\n        return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();\n    }\n\n    function computeDomainSeparator() internal view virtual returns (bytes32) {\n        return\n            keccak256(\n                abi.encode(\n                    keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\"),\n                    keccak256(bytes(name)),\n                    keccak256(\"1\"),\n                    block.chainid,\n                    address(this)\n                )\n            );\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                        INTERNAL MINT/BURN LOGIC\n    //////////////////////////////////////////////////////////////*/\n\n    function _mint(address to, uint256 amount) internal virtual {\n        totalSupply += amount;\n\n        // Cannot overflow because the sum of all user\n        // balances can't exceed the max uint256 value.\n        unchecked {\n            balanceOf[to] += amount;\n        }\n\n        emit Transfer(address(0), to, amount);\n    }\n\n    function _burn(address from, uint256 amount) internal virtual {\n        balanceOf[from] -= amount;\n\n        // Cannot underflow because a user's balance\n        // will never be larger than the total supply.\n        unchecked {\n            totalSupply -= amount;\n        }\n\n        emit Transfer(from, address(0), amount);\n    }\n}\n"
    },
    "contracts/splits/interfaces/ISplitMain.sol": {
      "content": "// SPDX-License-Identifier: GPL-3.0-or-later\npragma solidity ^0.8.4;\n\nimport {ERC20} from \"solmate/src/tokens/ERC20.sol\";\n\n/**\n * @title ISplitMain\n * @author 0xSplits <will@0xSplits.xyz>\n */\ninterface ISplitMain {\n  /**\n   * FUNCTIONS\n   */\n\n  function walletImplementation() external returns (address);\n\n  function createSplit(\n    address[] calldata accounts,\n    uint32[] calldata percentAllocations,\n    uint32 distributorFee,\n    address controller\n  ) external returns (address);\n\n  function predictImmutableSplitAddress(\n    address[] calldata accounts,\n    uint32[] calldata percentAllocations,\n    uint32 distributorFee\n  ) external view returns (address);\n\n  function updateSplit(\n    address split,\n    address[] calldata accounts,\n    uint32[] calldata percentAllocations,\n    uint32 distributorFee\n  ) external;\n\n  function transferControl(address split, address newController) external;\n\n  function cancelControlTransfer(address split) external;\n\n  function acceptControl(address split) external;\n\n  function makeSplitImmutable(address split) external;\n\n  function distributeETH(\n    address split,\n    address[] calldata accounts,\n    uint32[] calldata percentAllocations,\n    uint32 distributorFee,\n    address distributorAddress\n  ) external;\n\n  function updateAndDistributeETH(\n    address split,\n    address[] calldata accounts,\n    uint32[] calldata percentAllocations,\n    uint32 distributorFee,\n    address distributorAddress\n  ) external;\n\n  function distributeERC20(\n    address split,\n    ERC20 token,\n    address[] calldata accounts,\n    uint32[] calldata percentAllocations,\n    uint32 distributorFee,\n    address distributorAddress\n  ) external;\n\n  function updateAndDistributeERC20(\n    address split,\n    ERC20 token,\n    address[] calldata accounts,\n    uint32[] calldata percentAllocations,\n    uint32 distributorFee,\n    address distributorAddress\n  ) external;\n\n  function withdraw(\n    address account,\n    uint256 withdrawETH,\n    ERC20[] calldata tokens\n  ) external;\n\n  /**\n   * EVENTS\n   */\n\n  /** @notice emitted after each successful split creation\n   *  @param split Address of the created split\n   */\n  event CreateSplit(address indexed split);\n\n  /** @notice emitted after each successful split update\n   *  @param split Address of the updated split\n   */\n  event UpdateSplit(address indexed split);\n\n  /** @notice emitted after each initiated split control transfer\n   *  @param split Address of the split control transfer was initiated for\n   *  @param newPotentialController Address of the split's new potential controller\n   */\n  event InitiateControlTransfer(\n    address indexed split,\n    address indexed newPotentialController\n  );\n\n  /** @notice emitted after each canceled split control transfer\n   *  @param split Address of the split control transfer was canceled for\n   */\n  event CancelControlTransfer(address indexed split);\n\n  /** @notice emitted after each successful split control transfer\n   *  @param split Address of the split control was transferred for\n   *  @param previousController Address of the split's previous controller\n   *  @param newController Address of the split's new controller\n   */\n  event ControlTransfer(\n    address indexed split,\n    address indexed previousController,\n    address indexed newController\n  );\n\n  /** @notice emitted after each successful ETH balance split\n   *  @param split Address of the split that distributed its balance\n   *  @param amount Amount of ETH distributed\n   *  @param distributorAddress Address to credit distributor fee to\n   */\n  event DistributeETH(\n    address indexed split,\n    uint256 amount,\n    address indexed distributorAddress\n  );\n\n  /** @notice emitted after each successful ERC20 balance split\n   *  @param split Address of the split that distributed its balance\n   *  @param token Address of ERC20 distributed\n   *  @param amount Amount of ERC20 distributed\n   *  @param distributorAddress Address to credit distributor fee to\n   */\n  event DistributeERC20(\n    address indexed split,\n    ERC20 indexed token,\n    uint256 amount,\n    address indexed distributorAddress\n  );\n\n  /** @notice emitted after each successful withdrawal\n   *  @param account Address that funds were withdrawn to\n   *  @param ethAmount Amount of ETH withdrawn\n   *  @param tokens Addresses of ERC20s withdrawn\n   *  @param tokenAmounts Amounts of corresponding ERC20s withdrawn\n   */\n  event Withdrawal(\n    address indexed account,\n    uint256 ethAmount,\n    ERC20[] tokens,\n    uint256[] tokenAmounts\n  );\n}\n"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": true,
      "runs": 200
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    },
    "libraries": {}
  }
}