ETH Price: $2,181.53 (-10.01%)

Transaction Decoder

Block:
21963097 at Mar-03-2025 01:32:35 AM +UTC
Transaction Fee:
0.000129539718777833 ETH $0.28
Gas Used:
102,853 Gas / 1.259464661 Gwei

Emitted Events:

469 TransparentUpgradeableProxy.0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef( 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x000000000000000000000000eb41e9908c4fc1d3cee0ecc6266f89e3e9e04b29, 0x0000000000000000000000007e910c5654fe0291b63990c73af20ef35f50591f, 0x00000000000000000000000000000000000000000000000000000000000004b9 )

Account State Difference:

  Address   Before After State Difference Code
(Titan Builder)
9.298149337766187688 Eth9.298200764266187688 Eth0.0000514265
0x76927267...7ACc544Cc
0xEB41E990...3E9E04b29
0.00522245200358194 Eth
Nonce: 1709
0.005092912284804107 Eth
Nonce: 1710
0.000129539718777833

Execution Trace

TransferHelper.bulkTransfer( items=, conduitKey=0000007B02230091A7ED01230072F7006A004D60A8D4E71D599B8104250F0000 ) => ( items=, conduitKey= )
  • Conduit.execute( transfers= ) => ( transfers= )
    • TransparentUpgradeableProxy.23b872dd( )
      • Captainz.transferFrom( from=0xEB41E9908C4FC1D3Cee0ECc6266f89E3E9E04b29, to=0x7e910C5654fE0291b63990c73aF20EF35f50591f, tokenId=1209 )
        • OperatorFilterRegistry.isOperatorAllowed( registrant=0x769272677faB02575E84945F03Eca517ACc544Cc, operator=0x1E0049783F008A0085193E00003D00cd54003c71 ) => ( True )
        • OperatorFilterRegistry.isOperatorAllowed( registrant=0x769272677faB02575E84945F03Eca517ACc544Cc, operator=0xEB41E9908C4FC1D3Cee0ECc6266f89E3E9E04b29 ) => ( True )
          bulkTransfer[TransferHelper (ln:57)]
          File 1 of 5: TransferHelper
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.7;
          import { IERC721Receiver } from "../interfaces/IERC721Receiver.sol";
          import "./TransferHelperStructs.sol";
          import { ConduitInterface } from "../interfaces/ConduitInterface.sol";
          import {
              ConduitControllerInterface
          } from "../interfaces/ConduitControllerInterface.sol";
          import { Conduit } from "../conduit/Conduit.sol";
          import { ConduitTransfer } from "../conduit/lib/ConduitStructs.sol";
          import {
              TransferHelperInterface
          } from "../interfaces/TransferHelperInterface.sol";
          import { TransferHelperErrors } from "../interfaces/TransferHelperErrors.sol";
          /**
           * @title TransferHelper
           * @author stephankmin, stuckinaboot, ryanio
           * @notice TransferHelper is a utility contract for transferring
           *         ERC20/ERC721/ERC1155 items in bulk to specific recipients.
           */
          contract TransferHelper is TransferHelperInterface, TransferHelperErrors {
              // Allow for interaction with the conduit controller.
              ConduitControllerInterface internal immutable _CONDUIT_CONTROLLER;
              // Set conduit creation code and runtime code hashes as immutable arguments.
              bytes32 internal immutable _CONDUIT_CREATION_CODE_HASH;
              bytes32 internal immutable _CONDUIT_RUNTIME_CODE_HASH;
              /**
               * @dev Set the supplied conduit controller and retrieve its
               *      conduit creation code hash.
               *
               *
               * @param conduitController A contract that deploys conduits, or proxies
               *                          that may optionally be used to transfer approved
               *                          ERC20/721/1155 tokens.
               */
              constructor(address conduitController) {
                  // Get the conduit creation code and runtime code hashes from the
                  // supplied conduit controller and set them as an immutable.
                  ConduitControllerInterface controller = ConduitControllerInterface(
                      conduitController
                  );
                  (_CONDUIT_CREATION_CODE_HASH, _CONDUIT_RUNTIME_CODE_HASH) = controller
                      .getConduitCodeHashes();
                  // Set the supplied conduit controller as an immutable.
                  _CONDUIT_CONTROLLER = controller;
              }
              /**
               * @notice Transfer multiple ERC20/ERC721/ERC1155 items to
               *         specified recipients.
               *
               * @param items      The items to transfer to an intended recipient.
               * @param conduitKey An optional conduit key referring to a conduit through
               *                   which the bulk transfer should occur.
               *
               * @return magicValue A value indicating that the transfers were successful.
               */
              function bulkTransfer(
                  TransferHelperItemsWithRecipient[] calldata items,
                  bytes32 conduitKey
              ) external override returns (bytes4 magicValue) {
                  // Ensure that a conduit key has been supplied.
                  if (conduitKey == bytes32(0)) {
                      revert InvalidConduit(conduitKey, address(0));
                  }
                  // Use conduit derived from supplied conduit key to perform transfers.
                  _performTransfersWithConduit(items, conduitKey);
                  // Return a magic value indicating that the transfers were performed.
                  magicValue = this.bulkTransfer.selector;
              }
              /**
               * @notice Perform multiple transfers to specified recipients via the
               *         conduit derived from the provided conduit key.
               *
               * @param transfers  The items to transfer.
               * @param conduitKey The conduit key referring to the conduit through
               *                   which the bulk transfer should occur.
               */
              function _performTransfersWithConduit(
                  TransferHelperItemsWithRecipient[] calldata transfers,
                  bytes32 conduitKey
              ) internal {
                  // Retrieve total number of transfers and place on stack.
                  uint256 numTransfers = transfers.length;
                  // Derive the conduit address from the deployer, conduit key
                  // and creation code hash.
                  address conduit = address(
                      uint160(
                          uint256(
                              keccak256(
                                  abi.encodePacked(
                                      bytes1(0xff),
                                      address(_CONDUIT_CONTROLLER),
                                      conduitKey,
                                      _CONDUIT_CREATION_CODE_HASH
                                  )
                              )
                          )
                      )
                  );
                  // Declare a variable to store the sum of all items across transfers.
                  uint256 sumOfItemsAcrossAllTransfers;
                  // Skip overflow checks: all for loops are indexed starting at zero.
                  unchecked {
                      // Iterate over each transfer.
                      for (uint256 i = 0; i < numTransfers; ++i) {
                          // Retrieve the transfer in question.
                          TransferHelperItemsWithRecipient calldata transfer = transfers[
                              i
                          ];
                          // Increment totalItems by the number of items in the transfer.
                          sumOfItemsAcrossAllTransfers += transfer.items.length;
                      }
                  }
                  // Declare a new array in memory with length totalItems to populate with
                  // each conduit transfer.
                  ConduitTransfer[] memory conduitTransfers = new ConduitTransfer[](
                      sumOfItemsAcrossAllTransfers
                  );
                  // Declare an index for storing ConduitTransfers in conduitTransfers.
                  uint256 itemIndex;
                  // Skip overflow checks: all for loops are indexed starting at zero.
                  unchecked {
                      // Iterate over each transfer.
                      for (uint256 i = 0; i < numTransfers; ++i) {
                          // Retrieve the transfer in question.
                          TransferHelperItemsWithRecipient calldata transfer = transfers[
                              i
                          ];
                          // Retrieve the items of the transfer in question.
                          TransferHelperItem[] calldata transferItems = transfer.items;
                          // Ensure recipient is not the zero address.
                          _checkRecipientIsNotZeroAddress(transfer.recipient);
                          // Create a boolean indicating whether validateERC721Receiver
                          // is true and recipient is a contract.
                          bool callERC721Receiver = transfer.validateERC721Receiver &&
                              transfer.recipient.code.length != 0;
                          // Retrieve the total number of items in the transfer and
                          // place on stack.
                          uint256 numItemsInTransfer = transferItems.length;
                          // Iterate over each item in the transfer to create a
                          // corresponding ConduitTransfer.
                          for (uint256 j = 0; j < numItemsInTransfer; ++j) {
                              // Retrieve the item from the transfer.
                              TransferHelperItem calldata item = transferItems[j];
                              if (item.itemType == ConduitItemType.ERC20) {
                                  // Ensure that the identifier of an ERC20 token is 0.
                                  if (item.identifier != 0) {
                                      revert InvalidERC20Identifier();
                                  }
                              }
                              // If the item is an ERC721 token and
                              // callERC721Receiver is true...
                              if (item.itemType == ConduitItemType.ERC721) {
                                  if (callERC721Receiver) {
                                      // Check if the recipient implements
                                      // onERC721Received for the given tokenId.
                                      _checkERC721Receiver(
                                          conduit,
                                          transfer.recipient,
                                          item.identifier
                                      );
                                  }
                              }
                              // Create a ConduitTransfer corresponding to each
                              // TransferHelperItem.
                              conduitTransfers[itemIndex] = ConduitTransfer(
                                  item.itemType,
                                  item.token,
                                  msg.sender,
                                  transfer.recipient,
                                  item.identifier,
                                  item.amount
                              );
                              // Increment the index for storing ConduitTransfers.
                              ++itemIndex;
                          }
                      }
                  }
                  // Attempt the external call to transfer tokens via the derived conduit.
                  try ConduitInterface(conduit).execute(conduitTransfers) returns (
                      bytes4 conduitMagicValue
                  ) {
                      // Check if the value returned from the external call matches
                      // the conduit `execute` selector.
                      if (conduitMagicValue != ConduitInterface.execute.selector) {
                          // If the external call fails, revert with the conduit key
                          // and conduit address.
                          revert InvalidConduit(conduitKey, conduit);
                      }
                  } catch Error(string memory reason) {
                      // Catch reverts with a provided reason string and
                      // revert with the reason, conduit key and conduit address.
                      revert ConduitErrorRevertString(reason, conduitKey, conduit);
                  } catch (bytes memory data) {
                      // Conduits will throw a custom error when attempting to transfer
                      // native token item types or an ERC721 item amount other than 1.
                      // Bubble up these custom errors when encountered. Note that the
                      // conduit itself will bubble up revert reasons from transfers as
                      // well, meaning that these errors are not necessarily indicative of
                      // an issue with the item type or amount in cases where the same
                      // custom error signature is encountered during a conduit transfer.
                      // Set initial value of first four bytes of revert data to the mask.
                      bytes4 customErrorSelector = bytes4(0xffffffff);
                      // Utilize assembly to read first four bytes (if present) directly.
                      assembly {
                          // Combine original mask with first four bytes of revert data.
                          customErrorSelector := and(
                              mload(add(data, 0x20)), // Data begins after length offset.
                              customErrorSelector
                          )
                      }
                      // Pass through the custom error in question if the revert data is
                      // the correct length and matches an expected custom error selector.
                      if (
                          data.length == 4 &&
                          (customErrorSelector == InvalidItemType.selector ||
                              customErrorSelector == InvalidERC721TransferAmount.selector)
                      ) {
                          // "Bubble up" the revert reason.
                          assembly {
                              revert(add(data, 0x20), 0x04)
                          }
                      }
                      // Catch all other reverts from the external call to the conduit and
                      // include the conduit's raw revert reason as a data argument to a
                      // new custom error.
                      revert ConduitErrorRevertBytes(data, conduitKey, conduit);
                  }
              }
              /**
               * @notice An internal function to check if a recipient address implements
               *         onERC721Received for a given tokenId. Note that this check does
               *         not adhere to the safe transfer specification and is only meant
               *         to provide an additional layer of assurance that the recipient
               *         can receive the tokens — any hooks or post-transfer checks will
               *         fail and the caller will be the transfer helper rather than the
               *         ERC721 contract. Note that the conduit is set as the operator, as
               *         it will be the caller once the transfer is performed.
               *
               * @param conduit   The conduit to provide as the operator when calling
               *                  onERC721Received.
               * @param recipient The ERC721 recipient on which to call onERC721Received.
               * @param tokenId   The ERC721 tokenId of the token being transferred.
               */
              function _checkERC721Receiver(
                  address conduit,
                  address recipient,
                  uint256 tokenId
              ) internal {
                  // Check if recipient can receive ERC721 tokens.
                  try
                      IERC721Receiver(recipient).onERC721Received(
                          conduit,
                          msg.sender,
                          tokenId,
                          ""
                      )
                  returns (bytes4 selector) {
                      // Check if onERC721Received selector is valid.
                      if (selector != IERC721Receiver.onERC721Received.selector) {
                          // Revert if recipient cannot accept
                          // ERC721 tokens.
                          revert InvalidERC721Recipient(recipient);
                      }
                  } catch (bytes memory data) {
                      // "Bubble up" recipient's revert reason.
                      revert ERC721ReceiverErrorRevertBytes(
                          data,
                          recipient,
                          msg.sender,
                          tokenId
                      );
                  } catch Error(string memory reason) {
                      // "Bubble up" recipient's revert reason.
                      revert ERC721ReceiverErrorRevertString(
                          reason,
                          recipient,
                          msg.sender,
                          tokenId
                      );
                  }
              }
              /**
               * @notice An internal function that reverts if the passed-in recipient
               *         is the zero address.
               *
               * @param recipient The recipient on which to perform the check.
               */
              function _checkRecipientIsNotZeroAddress(address recipient) internal pure {
                  // Revert if the recipient is the zero address.
                  if (recipient == address(0x0)) {
                      revert RecipientCannotBeZeroAddress();
                  }
              }
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.7;
          interface IERC721Receiver {
              function onERC721Received(
                  address operator,
                  address from,
                  uint256 tokenId,
                  bytes calldata data
              ) external returns (bytes4);
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.7;
          import { ConduitItemType } from "../conduit/lib/ConduitEnums.sol";
          /**
           * @dev A TransferHelperItem specifies the itemType (ERC20/ERC721/ERC1155),
           *      token address, token identifier, and amount of the token to be
           *      transferred via the TransferHelper. For ERC20 tokens, identifier
           *      must be 0. For ERC721 tokens, amount must be 1.
           */
          struct TransferHelperItem {
              ConduitItemType itemType;
              address token;
              uint256 identifier;
              uint256 amount;
          }
          /**
           * @dev A TransferHelperItemsWithRecipient specifies the tokens to transfer
           *      via the TransferHelper, their intended recipient, and a boolean flag
           *      indicating whether onERC721Received should be called on a recipient
           *      contract.
           */
          struct TransferHelperItemsWithRecipient {
              TransferHelperItem[] items;
              address recipient;
              bool validateERC721Receiver;
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.7;
          import {
              ConduitTransfer,
              ConduitBatch1155Transfer
          } from "../conduit/lib/ConduitStructs.sol";
          /**
           * @title ConduitInterface
           * @author 0age
           * @notice ConduitInterface contains all external function interfaces, events,
           *         and errors for conduit contracts.
           */
          interface ConduitInterface {
              /**
               * @dev Revert with an error when attempting to execute transfers using a
               *      caller that does not have an open channel.
               */
              error ChannelClosed(address channel);
              /**
               * @dev Revert with an error when attempting to update a channel to the
               *      current status of that channel.
               */
              error ChannelStatusAlreadySet(address channel, bool isOpen);
              /**
               * @dev Revert with an error when attempting to execute a transfer for an
               *      item that does not have an ERC20/721/1155 item type.
               */
              error InvalidItemType();
              /**
               * @dev Revert with an error when attempting to update the status of a
               *      channel from a caller that is not the conduit controller.
               */
              error InvalidController();
              /**
               * @dev Emit an event whenever a channel is opened or closed.
               *
               * @param channel The channel that has been updated.
               * @param open    A boolean indicating whether the conduit is open or not.
               */
              event ChannelUpdated(address indexed channel, bool open);
              /**
               * @notice Execute a sequence of ERC20/721/1155 transfers. Only a caller
               *         with an open channel can call this function.
               *
               * @param transfers The ERC20/721/1155 transfers to perform.
               *
               * @return magicValue A magic value indicating that the transfers were
               *                    performed successfully.
               */
              function execute(ConduitTransfer[] calldata transfers)
                  external
                  returns (bytes4 magicValue);
              /**
               * @notice Execute a sequence of batch 1155 transfers. Only a caller with an
               *         open channel can call this function.
               *
               * @param batch1155Transfers The 1155 batch transfers to perform.
               *
               * @return magicValue A magic value indicating that the transfers were
               *                    performed successfully.
               */
              function executeBatch1155(
                  ConduitBatch1155Transfer[] calldata batch1155Transfers
              ) external returns (bytes4 magicValue);
              /**
               * @notice Execute a sequence of transfers, both single and batch 1155. Only
               *         a caller with an open channel can call this function.
               *
               * @param standardTransfers  The ERC20/721/1155 transfers to perform.
               * @param batch1155Transfers The 1155 batch transfers to perform.
               *
               * @return magicValue A magic value indicating that the transfers were
               *                    performed successfully.
               */
              function executeWithBatch1155(
                  ConduitTransfer[] calldata standardTransfers,
                  ConduitBatch1155Transfer[] calldata batch1155Transfers
              ) external returns (bytes4 magicValue);
              /**
               * @notice Open or close a given channel. Only callable by the controller.
               *
               * @param channel The channel to open or close.
               * @param isOpen  The status of the channel (either open or closed).
               */
              function updateChannel(address channel, bool isOpen) external;
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.7;
          /**
           * @title ConduitControllerInterface
           * @author 0age
           * @notice ConduitControllerInterface contains all external function interfaces,
           *         structs, events, and errors for the conduit controller.
           */
          interface ConduitControllerInterface {
              /**
               * @dev Track the conduit key, current owner, new potential owner, and open
               *      channels for each deployed conduit.
               */
              struct ConduitProperties {
                  bytes32 key;
                  address owner;
                  address potentialOwner;
                  address[] channels;
                  mapping(address => uint256) channelIndexesPlusOne;
              }
              /**
               * @dev Emit an event whenever a new conduit is created.
               *
               * @param conduit    The newly created conduit.
               * @param conduitKey The conduit key used to create the new conduit.
               */
              event NewConduit(address conduit, bytes32 conduitKey);
              /**
               * @dev Emit an event whenever conduit ownership is transferred.
               *
               * @param conduit       The conduit for which ownership has been
               *                      transferred.
               * @param previousOwner The previous owner of the conduit.
               * @param newOwner      The new owner of the conduit.
               */
              event OwnershipTransferred(
                  address indexed conduit,
                  address indexed previousOwner,
                  address indexed newOwner
              );
              /**
               * @dev Emit an event whenever a conduit owner registers a new potential
               *      owner for that conduit.
               *
               * @param newPotentialOwner The new potential owner of the conduit.
               */
              event PotentialOwnerUpdated(address indexed newPotentialOwner);
              /**
               * @dev Revert with an error when attempting to create a new conduit using a
               *      conduit key where the first twenty bytes of the key do not match the
               *      address of the caller.
               */
              error InvalidCreator();
              /**
               * @dev Revert with an error when attempting to create a new conduit when no
               *      initial owner address is supplied.
               */
              error InvalidInitialOwner();
              /**
               * @dev Revert with an error when attempting to set a new potential owner
               *      that is already set.
               */
              error NewPotentialOwnerAlreadySet(
                  address conduit,
                  address newPotentialOwner
              );
              /**
               * @dev Revert with an error when attempting to cancel ownership transfer
               *      when no new potential owner is currently set.
               */
              error NoPotentialOwnerCurrentlySet(address conduit);
              /**
               * @dev Revert with an error when attempting to interact with a conduit that
               *      does not yet exist.
               */
              error NoConduit();
              /**
               * @dev Revert with an error when attempting to create a conduit that
               *      already exists.
               */
              error ConduitAlreadyExists(address conduit);
              /**
               * @dev Revert with an error when attempting to update channels or transfer
               *      ownership of a conduit when the caller is not the owner of the
               *      conduit in question.
               */
              error CallerIsNotOwner(address conduit);
              /**
               * @dev Revert with an error when attempting to register a new potential
               *      owner and supplying the null address.
               */
              error NewPotentialOwnerIsZeroAddress(address conduit);
              /**
               * @dev Revert with an error when attempting to claim ownership of a conduit
               *      with a caller that is not the current potential owner for the
               *      conduit in question.
               */
              error CallerIsNotNewPotentialOwner(address conduit);
              /**
               * @dev Revert with an error when attempting to retrieve a channel using an
               *      index that is out of range.
               */
              error ChannelOutOfRange(address conduit);
              /**
               * @notice Deploy a new conduit using a supplied conduit key and assigning
               *         an initial owner for the deployed conduit. Note that the first
               *         twenty bytes of the supplied conduit key must match the caller
               *         and that a new conduit cannot be created if one has already been
               *         deployed using the same conduit key.
               *
               * @param conduitKey   The conduit key used to deploy the conduit. Note that
               *                     the first twenty bytes of the conduit key must match
               *                     the caller of this contract.
               * @param initialOwner The initial owner to set for the new conduit.
               *
               * @return conduit The address of the newly deployed conduit.
               */
              function createConduit(bytes32 conduitKey, address initialOwner)
                  external
                  returns (address conduit);
              /**
               * @notice Open or close a channel on a given conduit, thereby allowing the
               *         specified account to execute transfers against that conduit.
               *         Extreme care must be taken when updating channels, as malicious
               *         or vulnerable channels can transfer any ERC20, ERC721 and ERC1155
               *         tokens where the token holder has granted the conduit approval.
               *         Only the owner of the conduit in question may call this function.
               *
               * @param conduit The conduit for which to open or close the channel.
               * @param channel The channel to open or close on the conduit.
               * @param isOpen  A boolean indicating whether to open or close the channel.
               */
              function updateChannel(
                  address conduit,
                  address channel,
                  bool isOpen
              ) external;
              /**
               * @notice Initiate conduit ownership transfer by assigning a new potential
               *         owner for the given conduit. Once set, the new potential owner
               *         may call `acceptOwnership` to claim ownership of the conduit.
               *         Only the owner of the conduit in question may call this function.
               *
               * @param conduit The conduit for which to initiate ownership transfer.
               * @param newPotentialOwner The new potential owner of the conduit.
               */
              function transferOwnership(address conduit, address newPotentialOwner)
                  external;
              /**
               * @notice Clear the currently set potential owner, if any, from a conduit.
               *         Only the owner of the conduit in question may call this function.
               *
               * @param conduit The conduit for which to cancel ownership transfer.
               */
              function cancelOwnershipTransfer(address conduit) external;
              /**
               * @notice Accept ownership of a supplied conduit. Only accounts that the
               *         current owner has set as the new potential owner may call this
               *         function.
               *
               * @param conduit The conduit for which to accept ownership.
               */
              function acceptOwnership(address conduit) external;
              /**
               * @notice Retrieve the current owner of a deployed conduit.
               *
               * @param conduit The conduit for which to retrieve the associated owner.
               *
               * @return owner The owner of the supplied conduit.
               */
              function ownerOf(address conduit) external view returns (address owner);
              /**
               * @notice Retrieve the conduit key for a deployed conduit via reverse
               *         lookup.
               *
               * @param conduit The conduit for which to retrieve the associated conduit
               *                key.
               *
               * @return conduitKey The conduit key used to deploy the supplied conduit.
               */
              function getKey(address conduit) external view returns (bytes32 conduitKey);
              /**
               * @notice Derive the conduit associated with a given conduit key and
               *         determine whether that conduit exists (i.e. whether it has been
               *         deployed).
               *
               * @param conduitKey The conduit key used to derive the conduit.
               *
               * @return conduit The derived address of the conduit.
               * @return exists  A boolean indicating whether the derived conduit has been
               *                 deployed or not.
               */
              function getConduit(bytes32 conduitKey)
                  external
                  view
                  returns (address conduit, bool exists);
              /**
               * @notice Retrieve the potential owner, if any, for a given conduit. The
               *         current owner may set a new potential owner via
               *         `transferOwnership` and that owner may then accept ownership of
               *         the conduit in question via `acceptOwnership`.
               *
               * @param conduit The conduit for which to retrieve the potential owner.
               *
               * @return potentialOwner The potential owner, if any, for the conduit.
               */
              function getPotentialOwner(address conduit)
                  external
                  view
                  returns (address potentialOwner);
              /**
               * @notice Retrieve the status (either open or closed) of a given channel on
               *         a conduit.
               *
               * @param conduit The conduit for which to retrieve the channel status.
               * @param channel The channel for which to retrieve the status.
               *
               * @return isOpen The status of the channel on the given conduit.
               */
              function getChannelStatus(address conduit, address channel)
                  external
                  view
                  returns (bool isOpen);
              /**
               * @notice Retrieve the total number of open channels for a given conduit.
               *
               * @param conduit The conduit for which to retrieve the total channel count.
               *
               * @return totalChannels The total number of open channels for the conduit.
               */
              function getTotalChannels(address conduit)
                  external
                  view
                  returns (uint256 totalChannels);
              /**
               * @notice Retrieve an open channel at a specific index for a given conduit.
               *         Note that the index of a channel can change as a result of other
               *         channels being closed on the conduit.
               *
               * @param conduit      The conduit for which to retrieve the open channel.
               * @param channelIndex The index of the channel in question.
               *
               * @return channel The open channel, if any, at the specified channel index.
               */
              function getChannel(address conduit, uint256 channelIndex)
                  external
                  view
                  returns (address channel);
              /**
               * @notice Retrieve all open channels for a given conduit. Note that calling
               *         this function for a conduit with many channels will revert with
               *         an out-of-gas error.
               *
               * @param conduit The conduit for which to retrieve open channels.
               *
               * @return channels An array of open channels on the given conduit.
               */
              function getChannels(address conduit)
                  external
                  view
                  returns (address[] memory channels);
              /**
               * @dev Retrieve the conduit creation code and runtime code hashes.
               */
              function getConduitCodeHashes()
                  external
                  view
                  returns (bytes32 creationCodeHash, bytes32 runtimeCodeHash);
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.7;
          import { ConduitInterface } from "../interfaces/ConduitInterface.sol";
          import { ConduitItemType } from "./lib/ConduitEnums.sol";
          import { TokenTransferrer } from "../lib/TokenTransferrer.sol";
          import {
              ConduitTransfer,
              ConduitBatch1155Transfer
          } from "./lib/ConduitStructs.sol";
          import "./lib/ConduitConstants.sol";
          /**
           * @title Conduit
           * @author 0age
           * @notice This contract serves as an originator for "proxied" transfers. Each
           *         conduit is deployed and controlled by a "conduit controller" that can
           *         add and remove "channels" or contracts that can instruct the conduit
           *         to transfer approved ERC20/721/1155 tokens. *IMPORTANT NOTE: each
           *         conduit has an owner that can arbitrarily add or remove channels, and
           *         a malicious or negligent owner can add a channel that allows for any
           *         approved ERC20/721/1155 tokens to be taken immediately — be extremely
           *         cautious with what conduits you give token approvals to!*
           */
          contract Conduit is ConduitInterface, TokenTransferrer {
              // Set deployer as an immutable controller that can update channel statuses.
              address private immutable _controller;
              // Track the status of each channel.
              mapping(address => bool) private _channels;
              /**
               * @notice Ensure that the caller is currently registered as an open channel
               *         on the conduit.
               */
              modifier onlyOpenChannel() {
                  // Utilize assembly to access channel storage mapping directly.
                  assembly {
                      // Write the caller to scratch space.
                      mstore(ChannelKey_channel_ptr, caller())
                      // Write the storage slot for _channels to scratch space.
                      mstore(ChannelKey_slot_ptr, _channels.slot)
                      // Derive the position in storage of _channels[msg.sender]
                      // and check if the stored value is zero.
                      if iszero(
                          sload(keccak256(ChannelKey_channel_ptr, ChannelKey_length))
                      ) {
                          // The caller is not an open channel; revert with
                          // ChannelClosed(caller). First, set error signature in memory.
                          mstore(ChannelClosed_error_ptr, ChannelClosed_error_signature)
                          // Next, set the caller as the argument.
                          mstore(ChannelClosed_channel_ptr, caller())
                          // Finally, revert, returning full custom error with argument.
                          revert(ChannelClosed_error_ptr, ChannelClosed_error_length)
                      }
                  }
                  // Continue with function execution.
                  _;
              }
              /**
               * @notice In the constructor, set the deployer as the controller.
               */
              constructor() {
                  // Set the deployer as the controller.
                  _controller = msg.sender;
              }
              /**
               * @notice Execute a sequence of ERC20/721/1155 transfers. Only a caller
               *         with an open channel can call this function. Note that channels
               *         are expected to implement reentrancy protection if desired, and
               *         that cross-channel reentrancy may be possible if the conduit has
               *         multiple open channels at once. Also note that channels are
               *         expected to implement checks against transferring any zero-amount
               *         items if that constraint is desired.
               *
               * @param transfers The ERC20/721/1155 transfers to perform.
               *
               * @return magicValue A magic value indicating that the transfers were
               *                    performed successfully.
               */
              function execute(ConduitTransfer[] calldata transfers)
                  external
                  override
                  onlyOpenChannel
                  returns (bytes4 magicValue)
              {
                  // Retrieve the total number of transfers and place on the stack.
                  uint256 totalStandardTransfers = transfers.length;
                  // Iterate over each transfer.
                  for (uint256 i = 0; i < totalStandardTransfers; ) {
                      // Retrieve the transfer in question and perform the transfer.
                      _transfer(transfers[i]);
                      // Skip overflow check as for loop is indexed starting at zero.
                      unchecked {
                          ++i;
                      }
                  }
                  // Return a magic value indicating that the transfers were performed.
                  magicValue = this.execute.selector;
              }
              /**
               * @notice Execute a sequence of batch 1155 item transfers. Only a caller
               *         with an open channel can call this function. Note that channels
               *         are expected to implement reentrancy protection if desired, and
               *         that cross-channel reentrancy may be possible if the conduit has
               *         multiple open channels at once. Also note that channels are
               *         expected to implement checks against transferring any zero-amount
               *         items if that constraint is desired.
               *
               * @param batchTransfers The 1155 batch item transfers to perform.
               *
               * @return magicValue A magic value indicating that the item transfers were
               *                    performed successfully.
               */
              function executeBatch1155(
                  ConduitBatch1155Transfer[] calldata batchTransfers
              ) external override onlyOpenChannel returns (bytes4 magicValue) {
                  // Perform 1155 batch transfers. Note that memory should be considered
                  // entirely corrupted from this point forward.
                  _performERC1155BatchTransfers(batchTransfers);
                  // Return a magic value indicating that the transfers were performed.
                  magicValue = this.executeBatch1155.selector;
              }
              /**
               * @notice Execute a sequence of transfers, both single ERC20/721/1155 item
               *         transfers as well as batch 1155 item transfers. Only a caller
               *         with an open channel can call this function. Note that channels
               *         are expected to implement reentrancy protection if desired, and
               *         that cross-channel reentrancy may be possible if the conduit has
               *         multiple open channels at once. Also note that channels are
               *         expected to implement checks against transferring any zero-amount
               *         items if that constraint is desired.
               *
               * @param standardTransfers The ERC20/721/1155 item transfers to perform.
               * @param batchTransfers    The 1155 batch item transfers to perform.
               *
               * @return magicValue A magic value indicating that the item transfers were
               *                    performed successfully.
               */
              function executeWithBatch1155(
                  ConduitTransfer[] calldata standardTransfers,
                  ConduitBatch1155Transfer[] calldata batchTransfers
              ) external override onlyOpenChannel returns (bytes4 magicValue) {
                  // Retrieve the total number of transfers and place on the stack.
                  uint256 totalStandardTransfers = standardTransfers.length;
                  // Iterate over each standard transfer.
                  for (uint256 i = 0; i < totalStandardTransfers; ) {
                      // Retrieve the transfer in question and perform the transfer.
                      _transfer(standardTransfers[i]);
                      // Skip overflow check as for loop is indexed starting at zero.
                      unchecked {
                          ++i;
                      }
                  }
                  // Perform 1155 batch transfers. Note that memory should be considered
                  // entirely corrupted from this point forward aside from the free memory
                  // pointer having the default value.
                  _performERC1155BatchTransfers(batchTransfers);
                  // Return a magic value indicating that the transfers were performed.
                  magicValue = this.executeWithBatch1155.selector;
              }
              /**
               * @notice Open or close a given channel. Only callable by the controller.
               *
               * @param channel The channel to open or close.
               * @param isOpen  The status of the channel (either open or closed).
               */
              function updateChannel(address channel, bool isOpen) external override {
                  // Ensure that the caller is the controller of this contract.
                  if (msg.sender != _controller) {
                      revert InvalidController();
                  }
                  // Ensure that the channel does not already have the indicated status.
                  if (_channels[channel] == isOpen) {
                      revert ChannelStatusAlreadySet(channel, isOpen);
                  }
                  // Update the status of the channel.
                  _channels[channel] = isOpen;
                  // Emit a corresponding event.
                  emit ChannelUpdated(channel, isOpen);
              }
              /**
               * @dev Internal function to transfer a given ERC20/721/1155 item. Note that
               *      channels are expected to implement checks against transferring any
               *      zero-amount items if that constraint is desired.
               *
               * @param item The ERC20/721/1155 item to transfer.
               */
              function _transfer(ConduitTransfer calldata item) internal {
                  // Determine the transfer method based on the respective item type.
                  if (item.itemType == ConduitItemType.ERC20) {
                      // Transfer ERC20 token. Note that item.identifier is ignored and
                      // therefore ERC20 transfer items are potentially malleable — this
                      // check should be performed by the calling channel if a constraint
                      // on item malleability is desired.
                      _performERC20Transfer(item.token, item.from, item.to, item.amount);
                  } else if (item.itemType == ConduitItemType.ERC721) {
                      // Ensure that exactly one 721 item is being transferred.
                      if (item.amount != 1) {
                          revert InvalidERC721TransferAmount();
                      }
                      // Transfer ERC721 token.
                      _performERC721Transfer(
                          item.token,
                          item.from,
                          item.to,
                          item.identifier
                      );
                  } else if (item.itemType == ConduitItemType.ERC1155) {
                      // Transfer ERC1155 token.
                      _performERC1155Transfer(
                          item.token,
                          item.from,
                          item.to,
                          item.identifier,
                          item.amount
                      );
                  } else {
                      // Throw with an error.
                      revert InvalidItemType();
                  }
              }
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.7;
          import { ConduitItemType } from "./ConduitEnums.sol";
          struct ConduitTransfer {
              ConduitItemType itemType;
              address token;
              address from;
              address to;
              uint256 identifier;
              uint256 amount;
          }
          struct ConduitBatch1155Transfer {
              address token;
              address from;
              address to;
              uint256[] ids;
              uint256[] amounts;
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.7;
          import {
              TransferHelperItem,
              TransferHelperItemsWithRecipient
          } from "../helpers/TransferHelperStructs.sol";
          interface TransferHelperInterface {
              /**
               * @notice Transfer multiple items to a single recipient.
               *
               * @param items The items to transfer.
               * @param conduitKey  The key of the conduit performing the bulk transfer.
               */
              function bulkTransfer(
                  TransferHelperItemsWithRecipient[] calldata items,
                  bytes32 conduitKey
              ) external returns (bytes4);
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.7;
          /**
           * @title TransferHelperErrors
           */
          interface TransferHelperErrors {
              /**
               * @dev Revert with an error when attempting to execute transfers with a
               *      NATIVE itemType.
               */
              error InvalidItemType();
              /**
               * @dev Revert with an error when an ERC721 transfer with amount other than
               *      one is attempted.
               */
              error InvalidERC721TransferAmount();
              /**
               * @dev Revert with an error when attempting to execute an ERC721 transfer
               *      to an invalid recipient.
               */
              error InvalidERC721Recipient(address recipient);
              /**
               * @dev Revert with an error when a call to a ERC721 receiver reverts with
               *      bytes data.
               */
              error ERC721ReceiverErrorRevertBytes(
                  bytes reason,
                  address receiver,
                  address sender,
                  uint256 identifier
              );
              /**
               * @dev Revert with an error when a call to a ERC721 receiver reverts with
               *      string reason.
               */
              error ERC721ReceiverErrorRevertString(
                  string reason,
                  address receiver,
                  address sender,
                  uint256 identifier
              );
              /**
               * @dev Revert with an error when an ERC20 token has an invalid identifier.
               */
              error InvalidERC20Identifier();
              /**
               * @dev Revert with an error if the recipient is the zero address.
               */
              error RecipientCannotBeZeroAddress();
              /**
               * @dev Revert with an error when attempting to fill an order referencing an
               *      invalid conduit (i.e. one that has not been deployed).
               */
              error InvalidConduit(bytes32 conduitKey, address conduit);
              /**
               * @dev Revert with an error when a call to a conduit reverts with a
               *      reason string.
               */
              error ConduitErrorRevertString(
                  string reason,
                  bytes32 conduitKey,
                  address conduit
              );
              /**
               * @dev Revert with an error when a call to a conduit reverts with bytes
               *      data.
               */
              error ConduitErrorRevertBytes(
                  bytes reason,
                  bytes32 conduitKey,
                  address conduit
              );
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.7;
          enum ConduitItemType {
              NATIVE, // unused
              ERC20,
              ERC721,
              ERC1155
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.7;
          import "./TokenTransferrerConstants.sol";
          import {
              TokenTransferrerErrors
          } from "../interfaces/TokenTransferrerErrors.sol";
          import { ConduitBatch1155Transfer } from "../conduit/lib/ConduitStructs.sol";
          /**
           * @title TokenTransferrer
           * @author 0age
           * @custom:coauthor d1ll0n
           * @custom:coauthor transmissions11
           * @notice TokenTransferrer is a library for performing optimized ERC20, ERC721,
           *         ERC1155, and batch ERC1155 transfers, used by both Seaport as well as
           *         by conduits deployed by the ConduitController. Use great caution when
           *         considering these functions for use in other codebases, as there are
           *         significant side effects and edge cases that need to be thoroughly
           *         understood and carefully addressed.
           */
          contract TokenTransferrer is TokenTransferrerErrors {
              /**
               * @dev Internal function to transfer ERC20 tokens from a given originator
               *      to a given recipient. Sufficient approvals must be set on the
               *      contract performing the transfer.
               *
               * @param token      The ERC20 token to transfer.
               * @param from       The originator of the transfer.
               * @param to         The recipient of the transfer.
               * @param amount     The amount to transfer.
               */
              function _performERC20Transfer(
                  address token,
                  address from,
                  address to,
                  uint256 amount
              ) internal {
                  // Utilize assembly to perform an optimized ERC20 token transfer.
                  assembly {
                      // The free memory pointer memory slot will be used when populating
                      // call data for the transfer; read the value and restore it later.
                      let memPointer := mload(FreeMemoryPointerSlot)
                      // Write call data into memory, starting with function selector.
                      mstore(ERC20_transferFrom_sig_ptr, ERC20_transferFrom_signature)
                      mstore(ERC20_transferFrom_from_ptr, from)
                      mstore(ERC20_transferFrom_to_ptr, to)
                      mstore(ERC20_transferFrom_amount_ptr, amount)
                      // Make call & copy up to 32 bytes of return data to scratch space.
                      // Scratch space does not need to be cleared ahead of time, as the
                      // subsequent check will ensure that either at least a full word of
                      // return data is received (in which case it will be overwritten) or
                      // that no data is received (in which case scratch space will be
                      // ignored) on a successful call to the given token.
                      let callStatus := call(
                          gas(),
                          token,
                          0,
                          ERC20_transferFrom_sig_ptr,
                          ERC20_transferFrom_length,
                          0,
                          OneWord
                      )
                      // Determine whether transfer was successful using status & result.
                      let success := and(
                          // Set success to whether the call reverted, if not check it
                          // either returned exactly 1 (can't just be non-zero data), or
                          // had no return data.
                          or(
                              and(eq(mload(0), 1), gt(returndatasize(), 31)),
                              iszero(returndatasize())
                          ),
                          callStatus
                      )
                      // Handle cases where either the transfer failed or no data was
                      // returned. Group these, as most transfers will succeed with data.
                      // Equivalent to `or(iszero(success), iszero(returndatasize()))`
                      // but after it's inverted for JUMPI this expression is cheaper.
                      if iszero(and(success, iszero(iszero(returndatasize())))) {
                          // If the token has no code or the transfer failed: Equivalent
                          // to `or(iszero(success), iszero(extcodesize(token)))` but
                          // after it's inverted for JUMPI this expression is cheaper.
                          if iszero(and(iszero(iszero(extcodesize(token))), success)) {
                              // If the transfer failed:
                              if iszero(success) {
                                  // If it was due to a revert:
                                  if iszero(callStatus) {
                                      // If it returned a message, bubble it up as long as
                                      // sufficient gas remains to do so:
                                      if returndatasize() {
                                          // Ensure that sufficient gas is available to
                                          // copy returndata while expanding memory where
                                          // necessary. Start by computing the word size
                                          // of returndata and allocated memory. Round up
                                          // to the nearest full word.
                                          let returnDataWords := div(
                                              add(returndatasize(), AlmostOneWord),
                                              OneWord
                                          )
                                          // Note: use the free memory pointer in place of
                                          // msize() to work around a Yul warning that
                                          // prevents accessing msize directly when the IR
                                          // pipeline is activated.
                                          let msizeWords := div(memPointer, OneWord)
                                          // Next, compute the cost of the returndatacopy.
                                          let cost := mul(CostPerWord, returnDataWords)
                                          // Then, compute cost of new memory allocation.
                                          if gt(returnDataWords, msizeWords) {
                                              cost := add(
                                                  cost,
                                                  add(
                                                      mul(
                                                          sub(
                                                              returnDataWords,
                                                              msizeWords
                                                          ),
                                                          CostPerWord
                                                      ),
                                                      div(
                                                          sub(
                                                              mul(
                                                                  returnDataWords,
                                                                  returnDataWords
                                                              ),
                                                              mul(msizeWords, msizeWords)
                                                          ),
                                                          MemoryExpansionCoefficient
                                                      )
                                                  )
                                              )
                                          }
                                          // Finally, add a small constant and compare to
                                          // gas remaining; bubble up the revert data if
                                          // enough gas is still available.
                                          if lt(add(cost, ExtraGasBuffer), gas()) {
                                              // Copy returndata to memory; overwrite
                                              // existing memory.
                                              returndatacopy(0, 0, returndatasize())
                                              // Revert, specifying memory region with
                                              // copied returndata.
                                              revert(0, returndatasize())
                                          }
                                      }
                                      // Otherwise revert with a generic error message.
                                      mstore(
                                          TokenTransferGenericFailure_error_sig_ptr,
                                          TokenTransferGenericFailure_error_signature
                                      )
                                      mstore(
                                          TokenTransferGenericFailure_error_token_ptr,
                                          token
                                      )
                                      mstore(
                                          TokenTransferGenericFailure_error_from_ptr,
                                          from
                                      )
                                      mstore(TokenTransferGenericFailure_error_to_ptr, to)
                                      mstore(TokenTransferGenericFailure_error_id_ptr, 0)
                                      mstore(
                                          TokenTransferGenericFailure_error_amount_ptr,
                                          amount
                                      )
                                      revert(
                                          TokenTransferGenericFailure_error_sig_ptr,
                                          TokenTransferGenericFailure_error_length
                                      )
                                  }
                                  // Otherwise revert with a message about the token
                                  // returning false or non-compliant return values.
                                  mstore(
                                      BadReturnValueFromERC20OnTransfer_error_sig_ptr,
                                      BadReturnValueFromERC20OnTransfer_error_signature
                                  )
                                  mstore(
                                      BadReturnValueFromERC20OnTransfer_error_token_ptr,
                                      token
                                  )
                                  mstore(
                                      BadReturnValueFromERC20OnTransfer_error_from_ptr,
                                      from
                                  )
                                  mstore(
                                      BadReturnValueFromERC20OnTransfer_error_to_ptr,
                                      to
                                  )
                                  mstore(
                                      BadReturnValueFromERC20OnTransfer_error_amount_ptr,
                                      amount
                                  )
                                  revert(
                                      BadReturnValueFromERC20OnTransfer_error_sig_ptr,
                                      BadReturnValueFromERC20OnTransfer_error_length
                                  )
                              }
                              // Otherwise, revert with error about token not having code:
                              mstore(NoContract_error_sig_ptr, NoContract_error_signature)
                              mstore(NoContract_error_token_ptr, token)
                              revert(NoContract_error_sig_ptr, NoContract_error_length)
                          }
                          // Otherwise, the token just returned no data despite the call
                          // having succeeded; no need to optimize for this as it's not
                          // technically ERC20 compliant.
                      }
                      // Restore the original free memory pointer.
                      mstore(FreeMemoryPointerSlot, memPointer)
                      // Restore the zero slot to zero.
                      mstore(ZeroSlot, 0)
                  }
              }
              /**
               * @dev Internal function to transfer an ERC721 token from a given
               *      originator to a given recipient. Sufficient approvals must be set on
               *      the contract performing the transfer. Note that this function does
               *      not check whether the receiver can accept the ERC721 token (i.e. it
               *      does not use `safeTransferFrom`).
               *
               * @param token      The ERC721 token to transfer.
               * @param from       The originator of the transfer.
               * @param to         The recipient of the transfer.
               * @param identifier The tokenId to transfer.
               */
              function _performERC721Transfer(
                  address token,
                  address from,
                  address to,
                  uint256 identifier
              ) internal {
                  // Utilize assembly to perform an optimized ERC721 token transfer.
                  assembly {
                      // If the token has no code, revert.
                      if iszero(extcodesize(token)) {
                          mstore(NoContract_error_sig_ptr, NoContract_error_signature)
                          mstore(NoContract_error_token_ptr, token)
                          revert(NoContract_error_sig_ptr, NoContract_error_length)
                      }
                      // The free memory pointer memory slot will be used when populating
                      // call data for the transfer; read the value and restore it later.
                      let memPointer := mload(FreeMemoryPointerSlot)
                      // Write call data to memory starting with function selector.
                      mstore(ERC721_transferFrom_sig_ptr, ERC721_transferFrom_signature)
                      mstore(ERC721_transferFrom_from_ptr, from)
                      mstore(ERC721_transferFrom_to_ptr, to)
                      mstore(ERC721_transferFrom_id_ptr, identifier)
                      // Perform the call, ignoring return data.
                      let success := call(
                          gas(),
                          token,
                          0,
                          ERC721_transferFrom_sig_ptr,
                          ERC721_transferFrom_length,
                          0,
                          0
                      )
                      // If the transfer reverted:
                      if iszero(success) {
                          // If it returned a message, bubble it up as long as sufficient
                          // gas remains to do so:
                          if returndatasize() {
                              // Ensure that sufficient gas is available to copy
                              // returndata while expanding memory where necessary. Start
                              // by computing word size of returndata & allocated memory.
                              // Round up to the nearest full word.
                              let returnDataWords := div(
                                  add(returndatasize(), AlmostOneWord),
                                  OneWord
                              )
                              // Note: use the free memory pointer in place of msize() to
                              // work around a Yul warning that prevents accessing msize
                              // directly when the IR pipeline is activated.
                              let msizeWords := div(memPointer, OneWord)
                              // Next, compute the cost of the returndatacopy.
                              let cost := mul(CostPerWord, returnDataWords)
                              // Then, compute cost of new memory allocation.
                              if gt(returnDataWords, msizeWords) {
                                  cost := add(
                                      cost,
                                      add(
                                          mul(
                                              sub(returnDataWords, msizeWords),
                                              CostPerWord
                                          ),
                                          div(
                                              sub(
                                                  mul(returnDataWords, returnDataWords),
                                                  mul(msizeWords, msizeWords)
                                              ),
                                              MemoryExpansionCoefficient
                                          )
                                      )
                                  )
                              }
                              // Finally, add a small constant and compare to gas
                              // remaining; bubble up the revert data if enough gas is
                              // still available.
                              if lt(add(cost, ExtraGasBuffer), gas()) {
                                  // Copy returndata to memory; overwrite existing memory.
                                  returndatacopy(0, 0, returndatasize())
                                  // Revert, giving memory region with copied returndata.
                                  revert(0, returndatasize())
                              }
                          }
                          // Otherwise revert with a generic error message.
                          mstore(
                              TokenTransferGenericFailure_error_sig_ptr,
                              TokenTransferGenericFailure_error_signature
                          )
                          mstore(TokenTransferGenericFailure_error_token_ptr, token)
                          mstore(TokenTransferGenericFailure_error_from_ptr, from)
                          mstore(TokenTransferGenericFailure_error_to_ptr, to)
                          mstore(TokenTransferGenericFailure_error_id_ptr, identifier)
                          mstore(TokenTransferGenericFailure_error_amount_ptr, 1)
                          revert(
                              TokenTransferGenericFailure_error_sig_ptr,
                              TokenTransferGenericFailure_error_length
                          )
                      }
                      // Restore the original free memory pointer.
                      mstore(FreeMemoryPointerSlot, memPointer)
                      // Restore the zero slot to zero.
                      mstore(ZeroSlot, 0)
                  }
              }
              /**
               * @dev Internal function to transfer ERC1155 tokens from a given
               *      originator to a given recipient. Sufficient approvals must be set on
               *      the contract performing the transfer and contract recipients must
               *      implement the ERC1155TokenReceiver interface to indicate that they
               *      are willing to accept the transfer.
               *
               * @param token      The ERC1155 token to transfer.
               * @param from       The originator of the transfer.
               * @param to         The recipient of the transfer.
               * @param identifier The id to transfer.
               * @param amount     The amount to transfer.
               */
              function _performERC1155Transfer(
                  address token,
                  address from,
                  address to,
                  uint256 identifier,
                  uint256 amount
              ) internal {
                  // Utilize assembly to perform an optimized ERC1155 token transfer.
                  assembly {
                      // If the token has no code, revert.
                      if iszero(extcodesize(token)) {
                          mstore(NoContract_error_sig_ptr, NoContract_error_signature)
                          mstore(NoContract_error_token_ptr, token)
                          revert(NoContract_error_sig_ptr, NoContract_error_length)
                      }
                      // The following memory slots will be used when populating call data
                      // for the transfer; read the values and restore them later.
                      let memPointer := mload(FreeMemoryPointerSlot)
                      let slot0x80 := mload(Slot0x80)
                      let slot0xA0 := mload(Slot0xA0)
                      let slot0xC0 := mload(Slot0xC0)
                      // Write call data into memory, beginning with function selector.
                      mstore(
                          ERC1155_safeTransferFrom_sig_ptr,
                          ERC1155_safeTransferFrom_signature
                      )
                      mstore(ERC1155_safeTransferFrom_from_ptr, from)
                      mstore(ERC1155_safeTransferFrom_to_ptr, to)
                      mstore(ERC1155_safeTransferFrom_id_ptr, identifier)
                      mstore(ERC1155_safeTransferFrom_amount_ptr, amount)
                      mstore(
                          ERC1155_safeTransferFrom_data_offset_ptr,
                          ERC1155_safeTransferFrom_data_length_offset
                      )
                      mstore(ERC1155_safeTransferFrom_data_length_ptr, 0)
                      // Perform the call, ignoring return data.
                      let success := call(
                          gas(),
                          token,
                          0,
                          ERC1155_safeTransferFrom_sig_ptr,
                          ERC1155_safeTransferFrom_length,
                          0,
                          0
                      )
                      // If the transfer reverted:
                      if iszero(success) {
                          // If it returned a message, bubble it up as long as sufficient
                          // gas remains to do so:
                          if returndatasize() {
                              // Ensure that sufficient gas is available to copy
                              // returndata while expanding memory where necessary. Start
                              // by computing word size of returndata & allocated memory.
                              // Round up to the nearest full word.
                              let returnDataWords := div(
                                  add(returndatasize(), AlmostOneWord),
                                  OneWord
                              )
                              // Note: use the free memory pointer in place of msize() to
                              // work around a Yul warning that prevents accessing msize
                              // directly when the IR pipeline is activated.
                              let msizeWords := div(memPointer, OneWord)
                              // Next, compute the cost of the returndatacopy.
                              let cost := mul(CostPerWord, returnDataWords)
                              // Then, compute cost of new memory allocation.
                              if gt(returnDataWords, msizeWords) {
                                  cost := add(
                                      cost,
                                      add(
                                          mul(
                                              sub(returnDataWords, msizeWords),
                                              CostPerWord
                                          ),
                                          div(
                                              sub(
                                                  mul(returnDataWords, returnDataWords),
                                                  mul(msizeWords, msizeWords)
                                              ),
                                              MemoryExpansionCoefficient
                                          )
                                      )
                                  )
                              }
                              // Finally, add a small constant and compare to gas
                              // remaining; bubble up the revert data if enough gas is
                              // still available.
                              if lt(add(cost, ExtraGasBuffer), gas()) {
                                  // Copy returndata to memory; overwrite existing memory.
                                  returndatacopy(0, 0, returndatasize())
                                  // Revert, giving memory region with copied returndata.
                                  revert(0, returndatasize())
                              }
                          }
                          // Otherwise revert with a generic error message.
                          mstore(
                              TokenTransferGenericFailure_error_sig_ptr,
                              TokenTransferGenericFailure_error_signature
                          )
                          mstore(TokenTransferGenericFailure_error_token_ptr, token)
                          mstore(TokenTransferGenericFailure_error_from_ptr, from)
                          mstore(TokenTransferGenericFailure_error_to_ptr, to)
                          mstore(TokenTransferGenericFailure_error_id_ptr, identifier)
                          mstore(TokenTransferGenericFailure_error_amount_ptr, amount)
                          revert(
                              TokenTransferGenericFailure_error_sig_ptr,
                              TokenTransferGenericFailure_error_length
                          )
                      }
                      mstore(Slot0x80, slot0x80) // Restore slot 0x80.
                      mstore(Slot0xA0, slot0xA0) // Restore slot 0xA0.
                      mstore(Slot0xC0, slot0xC0) // Restore slot 0xC0.
                      // Restore the original free memory pointer.
                      mstore(FreeMemoryPointerSlot, memPointer)
                      // Restore the zero slot to zero.
                      mstore(ZeroSlot, 0)
                  }
              }
              /**
               * @dev Internal function to transfer ERC1155 tokens from a given
               *      originator to a given recipient. Sufficient approvals must be set on
               *      the contract performing the transfer and contract recipients must
               *      implement the ERC1155TokenReceiver interface to indicate that they
               *      are willing to accept the transfer. NOTE: this function is not
               *      memory-safe; it will overwrite existing memory, restore the free
               *      memory pointer to the default value, and overwrite the zero slot.
               *      This function should only be called once memory is no longer
               *      required and when uninitialized arrays are not utilized, and memory
               *      should be considered fully corrupted (aside from the existence of a
               *      default-value free memory pointer) after calling this function.
               *
               * @param batchTransfers The group of 1155 batch transfers to perform.
               */
              function _performERC1155BatchTransfers(
                  ConduitBatch1155Transfer[] calldata batchTransfers
              ) internal {
                  // Utilize assembly to perform optimized batch 1155 transfers.
                  assembly {
                      let len := batchTransfers.length
                      // Pointer to first head in the array, which is offset to the struct
                      // at each index. This gets incremented after each loop to avoid
                      // multiplying by 32 to get the offset for each element.
                      let nextElementHeadPtr := batchTransfers.offset
                      // Pointer to beginning of the head of the array. This is the
                      // reference position each offset references. It's held static to
                      // let each loop calculate the data position for an element.
                      let arrayHeadPtr := nextElementHeadPtr
                      // Write the function selector, which will be reused for each call:
                      // safeBatchTransferFrom(address,address,uint256[],uint256[],bytes)
                      mstore(
                          ConduitBatch1155Transfer_from_offset,
                          ERC1155_safeBatchTransferFrom_signature
                      )
                      // Iterate over each batch transfer.
                      for {
                          let i := 0
                      } lt(i, len) {
                          i := add(i, 1)
                      } {
                          // Read the offset to the beginning of the element and add
                          // it to pointer to the beginning of the array head to get
                          // the absolute position of the element in calldata.
                          let elementPtr := add(
                              arrayHeadPtr,
                              calldataload(nextElementHeadPtr)
                          )
                          // Retrieve the token from calldata.
                          let token := calldataload(elementPtr)
                          // If the token has no code, revert.
                          if iszero(extcodesize(token)) {
                              mstore(NoContract_error_sig_ptr, NoContract_error_signature)
                              mstore(NoContract_error_token_ptr, token)
                              revert(NoContract_error_sig_ptr, NoContract_error_length)
                          }
                          // Get the total number of supplied ids.
                          let idsLength := calldataload(
                              add(elementPtr, ConduitBatch1155Transfer_ids_length_offset)
                          )
                          // Determine the expected offset for the amounts array.
                          let expectedAmountsOffset := add(
                              ConduitBatch1155Transfer_amounts_length_baseOffset,
                              mul(idsLength, OneWord)
                          )
                          // Validate struct encoding.
                          let invalidEncoding := iszero(
                              and(
                                  // ids.length == amounts.length
                                  eq(
                                      idsLength,
                                      calldataload(add(elementPtr, expectedAmountsOffset))
                                  ),
                                  and(
                                      // ids_offset == 0xa0
                                      eq(
                                          calldataload(
                                              add(
                                                  elementPtr,
                                                  ConduitBatch1155Transfer_ids_head_offset
                                              )
                                          ),
                                          ConduitBatch1155Transfer_ids_length_offset
                                      ),
                                      // amounts_offset == 0xc0 + ids.length*32
                                      eq(
                                          calldataload(
                                              add(
                                                  elementPtr,
                                                  ConduitBatchTransfer_amounts_head_offset
                                              )
                                          ),
                                          expectedAmountsOffset
                                      )
                                  )
                              )
                          )
                          // Revert with an error if the encoding is not valid.
                          if invalidEncoding {
                              mstore(
                                  Invalid1155BatchTransferEncoding_ptr,
                                  Invalid1155BatchTransferEncoding_selector
                              )
                              revert(
                                  Invalid1155BatchTransferEncoding_ptr,
                                  Invalid1155BatchTransferEncoding_length
                              )
                          }
                          // Update the offset position for the next loop
                          nextElementHeadPtr := add(nextElementHeadPtr, OneWord)
                          // Copy the first section of calldata (before dynamic values).
                          calldatacopy(
                              BatchTransfer1155Params_ptr,
                              add(elementPtr, ConduitBatch1155Transfer_from_offset),
                              ConduitBatch1155Transfer_usable_head_size
                          )
                          // Determine size of calldata required for ids and amounts. Note
                          // that the size includes both lengths as well as the data.
                          let idsAndAmountsSize := add(TwoWords, mul(idsLength, TwoWords))
                          // Update the offset for the data array in memory.
                          mstore(
                              BatchTransfer1155Params_data_head_ptr,
                              add(
                                  BatchTransfer1155Params_ids_length_offset,
                                  idsAndAmountsSize
                              )
                          )
                          // Set the length of the data array in memory to zero.
                          mstore(
                              add(
                                  BatchTransfer1155Params_data_length_basePtr,
                                  idsAndAmountsSize
                              ),
                              0
                          )
                          // Determine the total calldata size for the call to transfer.
                          let transferDataSize := add(
                              BatchTransfer1155Params_calldata_baseSize,
                              idsAndAmountsSize
                          )
                          // Copy second section of calldata (including dynamic values).
                          calldatacopy(
                              BatchTransfer1155Params_ids_length_ptr,
                              add(elementPtr, ConduitBatch1155Transfer_ids_length_offset),
                              idsAndAmountsSize
                          )
                          // Perform the call to transfer 1155 tokens.
                          let success := call(
                              gas(),
                              token,
                              0,
                              ConduitBatch1155Transfer_from_offset, // Data portion start.
                              transferDataSize, // Location of the length of callData.
                              0,
                              0
                          )
                          // If the transfer reverted:
                          if iszero(success) {
                              // If it returned a message, bubble it up as long as
                              // sufficient gas remains to do so:
                              if returndatasize() {
                                  // Ensure that sufficient gas is available to copy
                                  // returndata while expanding memory where necessary.
                                  // Start by computing word size of returndata and
                                  // allocated memory. Round up to the nearest full word.
                                  let returnDataWords := div(
                                      add(returndatasize(), AlmostOneWord),
                                      OneWord
                                  )
                                  // Note: use transferDataSize in place of msize() to
                                  // work around a Yul warning that prevents accessing
                                  // msize directly when the IR pipeline is activated.
                                  // The free memory pointer is not used here because
                                  // this function does almost all memory management
                                  // manually and does not update it, and transferDataSize
                                  // should be the largest memory value used (unless a
                                  // previous batch was larger).
                                  let msizeWords := div(transferDataSize, OneWord)
                                  // Next, compute the cost of the returndatacopy.
                                  let cost := mul(CostPerWord, returnDataWords)
                                  // Then, compute cost of new memory allocation.
                                  if gt(returnDataWords, msizeWords) {
                                      cost := add(
                                          cost,
                                          add(
                                              mul(
                                                  sub(returnDataWords, msizeWords),
                                                  CostPerWord
                                              ),
                                              div(
                                                  sub(
                                                      mul(
                                                          returnDataWords,
                                                          returnDataWords
                                                      ),
                                                      mul(msizeWords, msizeWords)
                                                  ),
                                                  MemoryExpansionCoefficient
                                              )
                                          )
                                      )
                                  }
                                  // Finally, add a small constant and compare to gas
                                  // remaining; bubble up the revert data if enough gas is
                                  // still available.
                                  if lt(add(cost, ExtraGasBuffer), gas()) {
                                      // Copy returndata to memory; overwrite existing.
                                      returndatacopy(0, 0, returndatasize())
                                      // Revert with memory region containing returndata.
                                      revert(0, returndatasize())
                                  }
                              }
                              // Set the error signature.
                              mstore(
                                  0,
                                  ERC1155BatchTransferGenericFailure_error_signature
                              )
                              // Write the token.
                              mstore(ERC1155BatchTransferGenericFailure_token_ptr, token)
                              // Increase the offset to ids by 32.
                              mstore(
                                  BatchTransfer1155Params_ids_head_ptr,
                                  ERC1155BatchTransferGenericFailure_ids_offset
                              )
                              // Increase the offset to amounts by 32.
                              mstore(
                                  BatchTransfer1155Params_amounts_head_ptr,
                                  add(
                                      OneWord,
                                      mload(BatchTransfer1155Params_amounts_head_ptr)
                                  )
                              )
                              // Return modified region. The total size stays the same as
                              // `token` uses the same number of bytes as `data.length`.
                              revert(0, transferDataSize)
                          }
                      }
                      // Reset the free memory pointer to the default value; memory must
                      // be assumed to be dirtied and not reused from this point forward.
                      // Also note that the zero slot is not reset to zero, meaning empty
                      // arrays cannot be safely created or utilized until it is restored.
                      mstore(FreeMemoryPointerSlot, DefaultFreeMemoryPointer)
                  }
              }
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.7;
          // error ChannelClosed(address channel)
          uint256 constant ChannelClosed_error_signature = (
              0x93daadf200000000000000000000000000000000000000000000000000000000
          );
          uint256 constant ChannelClosed_error_ptr = 0x00;
          uint256 constant ChannelClosed_channel_ptr = 0x4;
          uint256 constant ChannelClosed_error_length = 0x24;
          // For the mapping:
          // mapping(address => bool) channels
          // The position in storage for a particular account is:
          // keccak256(abi.encode(account, channels.slot))
          uint256 constant ChannelKey_channel_ptr = 0x00;
          uint256 constant ChannelKey_slot_ptr = 0x20;
          uint256 constant ChannelKey_length = 0x40;
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.7;
          /*
           * -------------------------- Disambiguation & Other Notes ---------------------
           *    - The term "head" is used as it is in the documentation for ABI encoding,
           *      but only in reference to dynamic types, i.e. it always refers to the
           *      offset or pointer to the body of a dynamic type. In calldata, the head
           *      is always an offset (relative to the parent object), while in memory,
           *      the head is always the pointer to the body. More information found here:
           *      https://docs.soliditylang.org/en/v0.8.14/abi-spec.html#argument-encoding
           *        - Note that the length of an array is separate from and precedes the
           *          head of the array.
           *
           *    - The term "body" is used in place of the term "head" used in the ABI
           *      documentation. It refers to the start of the data for a dynamic type,
           *      e.g. the first word of a struct or the first word of the first element
           *      in an array.
           *
           *    - The term "pointer" is used to describe the absolute position of a value
           *      and never an offset relative to another value.
           *        - The suffix "_ptr" refers to a memory pointer.
           *        - The suffix "_cdPtr" refers to a calldata pointer.
           *
           *    - The term "offset" is used to describe the position of a value relative
           *      to some parent value. For example, OrderParameters_conduit_offset is the
           *      offset to the "conduit" value in the OrderParameters struct relative to
           *      the start of the body.
           *        - Note: Offsets are used to derive pointers.
           *
           *    - Some structs have pointers defined for all of their fields in this file.
           *      Lines which are commented out are fields that are not used in the
           *      codebase but have been left in for readability.
           */
          uint256 constant AlmostOneWord = 0x1f;
          uint256 constant OneWord = 0x20;
          uint256 constant TwoWords = 0x40;
          uint256 constant ThreeWords = 0x60;
          uint256 constant FreeMemoryPointerSlot = 0x40;
          uint256 constant ZeroSlot = 0x60;
          uint256 constant DefaultFreeMemoryPointer = 0x80;
          uint256 constant Slot0x80 = 0x80;
          uint256 constant Slot0xA0 = 0xa0;
          uint256 constant Slot0xC0 = 0xc0;
          // abi.encodeWithSignature("transferFrom(address,address,uint256)")
          uint256 constant ERC20_transferFrom_signature = (
              0x23b872dd00000000000000000000000000000000000000000000000000000000
          );
          uint256 constant ERC20_transferFrom_sig_ptr = 0x0;
          uint256 constant ERC20_transferFrom_from_ptr = 0x04;
          uint256 constant ERC20_transferFrom_to_ptr = 0x24;
          uint256 constant ERC20_transferFrom_amount_ptr = 0x44;
          uint256 constant ERC20_transferFrom_length = 0x64; // 4 + 32 * 3 == 100
          // abi.encodeWithSignature(
          //     "safeTransferFrom(address,address,uint256,uint256,bytes)"
          // )
          uint256 constant ERC1155_safeTransferFrom_signature = (
              0xf242432a00000000000000000000000000000000000000000000000000000000
          );
          uint256 constant ERC1155_safeTransferFrom_sig_ptr = 0x0;
          uint256 constant ERC1155_safeTransferFrom_from_ptr = 0x04;
          uint256 constant ERC1155_safeTransferFrom_to_ptr = 0x24;
          uint256 constant ERC1155_safeTransferFrom_id_ptr = 0x44;
          uint256 constant ERC1155_safeTransferFrom_amount_ptr = 0x64;
          uint256 constant ERC1155_safeTransferFrom_data_offset_ptr = 0x84;
          uint256 constant ERC1155_safeTransferFrom_data_length_ptr = 0xa4;
          uint256 constant ERC1155_safeTransferFrom_length = 0xc4; // 4 + 32 * 6 == 196
          uint256 constant ERC1155_safeTransferFrom_data_length_offset = 0xa0;
          // abi.encodeWithSignature(
          //     "safeBatchTransferFrom(address,address,uint256[],uint256[],bytes)"
          // )
          uint256 constant ERC1155_safeBatchTransferFrom_signature = (
              0x2eb2c2d600000000000000000000000000000000000000000000000000000000
          );
          bytes4 constant ERC1155_safeBatchTransferFrom_selector = bytes4(
              bytes32(ERC1155_safeBatchTransferFrom_signature)
          );
          uint256 constant ERC721_transferFrom_signature = ERC20_transferFrom_signature;
          uint256 constant ERC721_transferFrom_sig_ptr = 0x0;
          uint256 constant ERC721_transferFrom_from_ptr = 0x04;
          uint256 constant ERC721_transferFrom_to_ptr = 0x24;
          uint256 constant ERC721_transferFrom_id_ptr = 0x44;
          uint256 constant ERC721_transferFrom_length = 0x64; // 4 + 32 * 3 == 100
          // abi.encodeWithSignature("NoContract(address)")
          uint256 constant NoContract_error_signature = (
              0x5f15d67200000000000000000000000000000000000000000000000000000000
          );
          uint256 constant NoContract_error_sig_ptr = 0x0;
          uint256 constant NoContract_error_token_ptr = 0x4;
          uint256 constant NoContract_error_length = 0x24; // 4 + 32 == 36
          // abi.encodeWithSignature(
          //     "TokenTransferGenericFailure(address,address,address,uint256,uint256)"
          // )
          uint256 constant TokenTransferGenericFailure_error_signature = (
              0xf486bc8700000000000000000000000000000000000000000000000000000000
          );
          uint256 constant TokenTransferGenericFailure_error_sig_ptr = 0x0;
          uint256 constant TokenTransferGenericFailure_error_token_ptr = 0x4;
          uint256 constant TokenTransferGenericFailure_error_from_ptr = 0x24;
          uint256 constant TokenTransferGenericFailure_error_to_ptr = 0x44;
          uint256 constant TokenTransferGenericFailure_error_id_ptr = 0x64;
          uint256 constant TokenTransferGenericFailure_error_amount_ptr = 0x84;
          // 4 + 32 * 5 == 164
          uint256 constant TokenTransferGenericFailure_error_length = 0xa4;
          // abi.encodeWithSignature(
          //     "BadReturnValueFromERC20OnTransfer(address,address,address,uint256)"
          // )
          uint256 constant BadReturnValueFromERC20OnTransfer_error_signature = (
              0x9889192300000000000000000000000000000000000000000000000000000000
          );
          uint256 constant BadReturnValueFromERC20OnTransfer_error_sig_ptr = 0x0;
          uint256 constant BadReturnValueFromERC20OnTransfer_error_token_ptr = 0x4;
          uint256 constant BadReturnValueFromERC20OnTransfer_error_from_ptr = 0x24;
          uint256 constant BadReturnValueFromERC20OnTransfer_error_to_ptr = 0x44;
          uint256 constant BadReturnValueFromERC20OnTransfer_error_amount_ptr = 0x64;
          // 4 + 32 * 4 == 132
          uint256 constant BadReturnValueFromERC20OnTransfer_error_length = 0x84;
          uint256 constant ExtraGasBuffer = 0x20;
          uint256 constant CostPerWord = 3;
          uint256 constant MemoryExpansionCoefficient = 0x200;
          // Values are offset by 32 bytes in order to write the token to the beginning
          // in the event of a revert
          uint256 constant BatchTransfer1155Params_ptr = 0x24;
          uint256 constant BatchTransfer1155Params_ids_head_ptr = 0x64;
          uint256 constant BatchTransfer1155Params_amounts_head_ptr = 0x84;
          uint256 constant BatchTransfer1155Params_data_head_ptr = 0xa4;
          uint256 constant BatchTransfer1155Params_data_length_basePtr = 0xc4;
          uint256 constant BatchTransfer1155Params_calldata_baseSize = 0xc4;
          uint256 constant BatchTransfer1155Params_ids_length_ptr = 0xc4;
          uint256 constant BatchTransfer1155Params_ids_length_offset = 0xa0;
          uint256 constant BatchTransfer1155Params_amounts_length_baseOffset = 0xc0;
          uint256 constant BatchTransfer1155Params_data_length_baseOffset = 0xe0;
          uint256 constant ConduitBatch1155Transfer_usable_head_size = 0x80;
          uint256 constant ConduitBatch1155Transfer_from_offset = 0x20;
          uint256 constant ConduitBatch1155Transfer_ids_head_offset = 0x60;
          uint256 constant ConduitBatch1155Transfer_amounts_head_offset = 0x80;
          uint256 constant ConduitBatch1155Transfer_ids_length_offset = 0xa0;
          uint256 constant ConduitBatch1155Transfer_amounts_length_baseOffset = 0xc0;
          uint256 constant ConduitBatch1155Transfer_calldata_baseSize = 0xc0;
          // Note: abbreviated version of above constant to adhere to line length limit.
          uint256 constant ConduitBatchTransfer_amounts_head_offset = 0x80;
          uint256 constant Invalid1155BatchTransferEncoding_ptr = 0x00;
          uint256 constant Invalid1155BatchTransferEncoding_length = 0x04;
          uint256 constant Invalid1155BatchTransferEncoding_selector = (
              0xeba2084c00000000000000000000000000000000000000000000000000000000
          );
          uint256 constant ERC1155BatchTransferGenericFailure_error_signature = (
              0xafc445e200000000000000000000000000000000000000000000000000000000
          );
          uint256 constant ERC1155BatchTransferGenericFailure_token_ptr = 0x04;
          uint256 constant ERC1155BatchTransferGenericFailure_ids_offset = 0xc0;
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.7;
          /**
           * @title TokenTransferrerErrors
           */
          interface TokenTransferrerErrors {
              /**
               * @dev Revert with an error when an ERC721 transfer with amount other than
               *      one is attempted.
               */
              error InvalidERC721TransferAmount();
              /**
               * @dev Revert with an error when attempting to fulfill an order where an
               *      item has an amount of zero.
               */
              error MissingItemAmount();
              /**
               * @dev Revert with an error when attempting to fulfill an order where an
               *      item has unused parameters. This includes both the token and the
               *      identifier parameters for native transfers as well as the identifier
               *      parameter for ERC20 transfers. Note that the conduit does not
               *      perform this check, leaving it up to the calling channel to enforce
               *      when desired.
               */
              error UnusedItemParameters();
              /**
               * @dev Revert with an error when an ERC20, ERC721, or ERC1155 token
               *      transfer reverts.
               *
               * @param token      The token for which the transfer was attempted.
               * @param from       The source of the attempted transfer.
               * @param to         The recipient of the attempted transfer.
               * @param identifier The identifier for the attempted transfer.
               * @param amount     The amount for the attempted transfer.
               */
              error TokenTransferGenericFailure(
                  address token,
                  address from,
                  address to,
                  uint256 identifier,
                  uint256 amount
              );
              /**
               * @dev Revert with an error when a batch ERC1155 token transfer reverts.
               *
               * @param token       The token for which the transfer was attempted.
               * @param from        The source of the attempted transfer.
               * @param to          The recipient of the attempted transfer.
               * @param identifiers The identifiers for the attempted transfer.
               * @param amounts     The amounts for the attempted transfer.
               */
              error ERC1155BatchTransferGenericFailure(
                  address token,
                  address from,
                  address to,
                  uint256[] identifiers,
                  uint256[] amounts
              );
              /**
               * @dev Revert with an error when an ERC20 token transfer returns a falsey
               *      value.
               *
               * @param token      The token for which the ERC20 transfer was attempted.
               * @param from       The source of the attempted ERC20 transfer.
               * @param to         The recipient of the attempted ERC20 transfer.
               * @param amount     The amount for the attempted ERC20 transfer.
               */
              error BadReturnValueFromERC20OnTransfer(
                  address token,
                  address from,
                  address to,
                  uint256 amount
              );
              /**
               * @dev Revert with an error when an account being called as an assumed
               *      contract does not have code and returns no data.
               *
               * @param account The account that should contain code.
               */
              error NoContract(address account);
              /**
               * @dev Revert with an error when attempting to execute an 1155 batch
               *      transfer using calldata not produced by default ABI encoding or with
               *      different lengths for ids and amounts arrays.
               */
              error Invalid1155BatchTransferEncoding();
          }
          

          File 2 of 5: TransparentUpgradeableProxy
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.0;
          import "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
          import "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
          import "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
          // Kept for backwards compatibility with older versions of Hardhat and Truffle plugins.
          contract AdminUpgradeabilityProxy is TransparentUpgradeableProxy {
              constructor(address logic, address admin, bytes memory data) payable TransparentUpgradeableProxy(logic, admin, data) {}
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.0;
          import "../Proxy.sol";
          import "./ERC1967Upgrade.sol";
          /**
           * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an
           * implementation address that can be changed. This address is stored in storage in the location specified by
           * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the
           * implementation behind the proxy.
           */
          contract ERC1967Proxy is Proxy, ERC1967Upgrade {
              /**
               * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.
               *
               * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded
               * function call, and allows initializating the storage of the proxy like a Solidity constructor.
               */
              constructor(address _logic, bytes memory _data) payable {
                  assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
                  _upgradeToAndCall(_logic, _data, false);
              }
              /**
               * @dev Returns the current implementation address.
               */
              function _implementation() internal view virtual override returns (address impl) {
                  return ERC1967Upgrade._getImplementation();
              }
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.0;
          import "../ERC1967/ERC1967Proxy.sol";
          /**
           * @dev This contract implements a proxy that is upgradeable by an admin.
           *
           * To avoid https://medium.com/nomic-labs-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357[proxy selector
           * clashing], which can potentially be used in an attack, this contract uses the
           * https://blog.openzeppelin.com/the-transparent-proxy-pattern/[transparent proxy pattern]. This pattern implies two
           * things that go hand in hand:
           *
           * 1. If any account other than the admin calls the proxy, the call will be forwarded to the implementation, even if
           * that call matches one of the admin functions exposed by the proxy itself.
           * 2. If the admin calls the proxy, it can access the admin functions, but its calls will never be forwarded to the
           * implementation. If the admin tries to call a function on the implementation it will fail with an error that says
           * "admin cannot fallback to proxy target".
           *
           * These properties mean that the admin account can only be used for admin actions like upgrading the proxy or changing
           * the admin, so it's best if it's a dedicated account that is not used for anything else. This will avoid headaches due
           * to sudden errors when trying to call a function from the proxy implementation.
           *
           * Our recommendation is for the dedicated account to be an instance of the {ProxyAdmin} contract. If set up this way,
           * you should think of the `ProxyAdmin` instance as the real administrative interface of your proxy.
           */
          contract TransparentUpgradeableProxy is ERC1967Proxy {
              /**
               * @dev Initializes an upgradeable proxy managed by `_admin`, backed by the implementation at `_logic`, and
               * optionally initialized with `_data` as explained in {ERC1967Proxy-constructor}.
               */
              constructor(address _logic, address admin_, bytes memory _data) payable ERC1967Proxy(_logic, _data) {
                  assert(_ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1));
                  _changeAdmin(admin_);
              }
              /**
               * @dev Modifier used internally that will delegate the call to the implementation unless the sender is the admin.
               */
              modifier ifAdmin() {
                  if (msg.sender == _getAdmin()) {
                      _;
                  } else {
                      _fallback();
                  }
              }
              /**
               * @dev Returns the current admin.
               *
               * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyAdmin}.
               *
               * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the
               * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
               * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`
               */
              function admin() external ifAdmin returns (address admin_) {
                  admin_ = _getAdmin();
              }
              /**
               * @dev Returns the current implementation.
               *
               * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyImplementation}.
               *
               * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the
               * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
               * `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`
               */
              function implementation() external ifAdmin returns (address implementation_) {
                  implementation_ = _implementation();
              }
              /**
               * @dev Changes the admin of the proxy.
               *
               * Emits an {AdminChanged} event.
               *
               * NOTE: Only the admin can call this function. See {ProxyAdmin-changeProxyAdmin}.
               */
              function changeAdmin(address newAdmin) external virtual ifAdmin {
                  _changeAdmin(newAdmin);
              }
              /**
               * @dev Upgrade the implementation of the proxy.
               *
               * NOTE: Only the admin can call this function. See {ProxyAdmin-upgrade}.
               */
              function upgradeTo(address newImplementation) external ifAdmin {
                  _upgradeToAndCall(newImplementation, bytes(""), false);
              }
              /**
               * @dev Upgrade the implementation of the proxy, and then call a function from the new implementation as specified
               * by `data`, which should be an encoded function call. This is useful to initialize new storage variables in the
               * proxied contract.
               *
               * NOTE: Only the admin can call this function. See {ProxyAdmin-upgradeAndCall}.
               */
              function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {
                  _upgradeToAndCall(newImplementation, data, true);
              }
              /**
               * @dev Returns the current admin.
               */
              function _admin() internal view virtual returns (address) {
                  return _getAdmin();
              }
              /**
               * @dev Makes sure the admin cannot access the fallback function. See {Proxy-_beforeFallback}.
               */
              function _beforeFallback() internal virtual override {
                  require(msg.sender != _getAdmin(), "TransparentUpgradeableProxy: admin cannot fallback to proxy target");
                  super._beforeFallback();
              }
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.0;
          import "./TransparentUpgradeableProxy.sol";
          import "../../access/Ownable.sol";
          /**
           * @dev This is an auxiliary contract meant to be assigned as the admin of a {TransparentUpgradeableProxy}. For an
           * explanation of why you would want to use this see the documentation for {TransparentUpgradeableProxy}.
           */
          contract ProxyAdmin is Ownable {
              /**
               * @dev Returns the current implementation of `proxy`.
               *
               * Requirements:
               *
               * - This contract must be the admin of `proxy`.
               */
              function getProxyImplementation(TransparentUpgradeableProxy proxy) public view virtual returns (address) {
                  // We need to manually run the static call since the getter cannot be flagged as view
                  // bytes4(keccak256("implementation()")) == 0x5c60da1b
                  (bool success, bytes memory returndata) = address(proxy).staticcall(hex"5c60da1b");
                  require(success);
                  return abi.decode(returndata, (address));
              }
              /**
               * @dev Returns the current admin of `proxy`.
               *
               * Requirements:
               *
               * - This contract must be the admin of `proxy`.
               */
              function getProxyAdmin(TransparentUpgradeableProxy proxy) public view virtual returns (address) {
                  // We need to manually run the static call since the getter cannot be flagged as view
                  // bytes4(keccak256("admin()")) == 0xf851a440
                  (bool success, bytes memory returndata) = address(proxy).staticcall(hex"f851a440");
                  require(success);
                  return abi.decode(returndata, (address));
              }
              /**
               * @dev Changes the admin of `proxy` to `newAdmin`.
               *
               * Requirements:
               *
               * - This contract must be the current admin of `proxy`.
               */
              function changeProxyAdmin(TransparentUpgradeableProxy proxy, address newAdmin) public virtual onlyOwner {
                  proxy.changeAdmin(newAdmin);
              }
              /**
               * @dev Upgrades `proxy` to `implementation`. See {TransparentUpgradeableProxy-upgradeTo}.
               *
               * Requirements:
               *
               * - This contract must be the admin of `proxy`.
               */
              function upgrade(TransparentUpgradeableProxy proxy, address implementation) public virtual onlyOwner {
                  proxy.upgradeTo(implementation);
              }
              /**
               * @dev Upgrades `proxy` to `implementation` and calls a function on the new implementation. See
               * {TransparentUpgradeableProxy-upgradeToAndCall}.
               *
               * Requirements:
               *
               * - This contract must be the admin of `proxy`.
               */
              function upgradeAndCall(TransparentUpgradeableProxy proxy, address implementation, bytes memory data) public payable virtual onlyOwner {
                  proxy.upgradeToAndCall{value: msg.value}(implementation, data);
              }
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.0;
          /**
           * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM
           * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to
           * be specified by overriding the virtual {_implementation} function.
           *
           * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a
           * different contract through the {_delegate} function.
           *
           * The success and return data of the delegated call will be returned back to the caller of the proxy.
           */
          abstract contract Proxy {
              /**
               * @dev Delegates the current call to `implementation`.
               *
               * This function does not return to its internall call site, it will return directly to the external caller.
               */
              function _delegate(address implementation) internal virtual {
                  // solhint-disable-next-line no-inline-assembly
                  assembly {
                      // Copy msg.data. We take full control of memory in this inline assembly
                      // block because it will not return to Solidity code. We overwrite the
                      // Solidity scratch pad at memory position 0.
                      calldatacopy(0, 0, calldatasize())
                      // Call the implementation.
                      // out and outsize are 0 because we don't know the size yet.
                      let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
                      // Copy the returned data.
                      returndatacopy(0, 0, returndatasize())
                      switch result
                      // delegatecall returns 0 on error.
                      case 0 { revert(0, returndatasize()) }
                      default { return(0, returndatasize()) }
                  }
              }
              /**
               * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function
               * and {_fallback} should delegate.
               */
              function _implementation() internal view virtual returns (address);
              /**
               * @dev Delegates the current call to the address returned by `_implementation()`.
               *
               * This function does not return to its internall call site, it will return directly to the external caller.
               */
              function _fallback() internal virtual {
                  _beforeFallback();
                  _delegate(_implementation());
              }
              /**
               * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other
               * function in the contract matches the call data.
               */
              fallback () external payable virtual {
                  _fallback();
              }
              /**
               * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data
               * is empty.
               */
              receive () external payable virtual {
                  _fallback();
              }
              /**
               * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`
               * call, or as part of the Solidity `fallback` or `receive` functions.
               *
               * If overriden should call `super._beforeFallback()`.
               */
              function _beforeFallback() internal virtual {
              }
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.2;
          import "../beacon/IBeacon.sol";
          import "../../utils/Address.sol";
          import "../../utils/StorageSlot.sol";
          /**
           * @dev This abstract contract provides getters and event emitting update functions for
           * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
           *
           * _Available since v4.1._
           *
           * @custom:oz-upgrades-unsafe-allow delegatecall
           */
          abstract contract ERC1967Upgrade {
              // This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
              bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
              /**
               * @dev Storage slot with the address of the current implementation.
               * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
               * validated in the constructor.
               */
              bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
              /**
               * @dev Emitted when the implementation is upgraded.
               */
              event Upgraded(address indexed implementation);
              /**
               * @dev Returns the current implementation address.
               */
              function _getImplementation() internal view returns (address) {
                  return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
              }
              /**
               * @dev Stores a new address in the EIP1967 implementation slot.
               */
              function _setImplementation(address newImplementation) private {
                  require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
                  StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
              }
              /**
               * @dev Perform implementation upgrade
               *
               * Emits an {Upgraded} event.
               */
              function _upgradeTo(address newImplementation) internal {
                  _setImplementation(newImplementation);
                  emit Upgraded(newImplementation);
              }
              /**
               * @dev Perform implementation upgrade with additional setup call.
               *
               * Emits an {Upgraded} event.
               */
              function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal {
                  _setImplementation(newImplementation);
                  emit Upgraded(newImplementation);
                  if (data.length > 0 || forceCall) {
                      Address.functionDelegateCall(newImplementation, data);
                  }
              }
              /**
               * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
               *
               * Emits an {Upgraded} event.
               */
              function _upgradeToAndCallSecure(address newImplementation, bytes memory data, bool forceCall) internal {
                  address oldImplementation = _getImplementation();
                  // Initial upgrade and setup call
                  _setImplementation(newImplementation);
                  if (data.length > 0 || forceCall) {
                      Address.functionDelegateCall(newImplementation, data);
                  }
                  // Perform rollback test if not already in progress
                  StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot.getBooleanSlot(_ROLLBACK_SLOT);
                  if (!rollbackTesting.value) {
                      // Trigger rollback using upgradeTo from the new implementation
                      rollbackTesting.value = true;
                      Address.functionDelegateCall(
                          newImplementation,
                          abi.encodeWithSignature(
                              "upgradeTo(address)",
                              oldImplementation
                          )
                      );
                      rollbackTesting.value = false;
                      // Check rollback was effective
                      require(oldImplementation == _getImplementation(), "ERC1967Upgrade: upgrade breaks further upgrades");
                      // Finally reset to the new implementation and log the upgrade
                      _setImplementation(newImplementation);
                      emit Upgraded(newImplementation);
                  }
              }
              /**
               * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does
               * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).
               *
               * Emits a {BeaconUpgraded} event.
               */
              function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal {
                  _setBeacon(newBeacon);
                  emit BeaconUpgraded(newBeacon);
                  if (data.length > 0 || forceCall) {
                      Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
                  }
              }
              /**
               * @dev Storage slot with the admin of the contract.
               * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
               * validated in the constructor.
               */
              bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
              /**
               * @dev Emitted when the admin account has changed.
               */
              event AdminChanged(address previousAdmin, address newAdmin);
              /**
               * @dev Returns the current admin.
               */
              function _getAdmin() internal view returns (address) {
                  return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
              }
              /**
               * @dev Stores a new address in the EIP1967 admin slot.
               */
              function _setAdmin(address newAdmin) private {
                  require(newAdmin != address(0), "ERC1967: new admin is the zero address");
                  StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
              }
              /**
               * @dev Changes the admin of the proxy.
               *
               * Emits an {AdminChanged} event.
               */
              function _changeAdmin(address newAdmin) internal {
                  emit AdminChanged(_getAdmin(), newAdmin);
                  _setAdmin(newAdmin);
              }
              /**
               * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
               * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.
               */
              bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
              /**
               * @dev Emitted when the beacon is upgraded.
               */
              event BeaconUpgraded(address indexed beacon);
              /**
               * @dev Returns the current beacon.
               */
              function _getBeacon() internal view returns (address) {
                  return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
              }
              /**
               * @dev Stores a new beacon in the EIP1967 beacon slot.
               */
              function _setBeacon(address newBeacon) private {
                  require(
                      Address.isContract(newBeacon),
                      "ERC1967: new beacon is not a contract"
                  );
                  require(
                      Address.isContract(IBeacon(newBeacon).implementation()),
                      "ERC1967: beacon implementation is not a contract"
                  );
                  StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
              }
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.0;
          /**
           * @dev This is the interface that {BeaconProxy} expects of its beacon.
           */
          interface IBeacon {
              /**
               * @dev Must return an address that can be used as a delegate call target.
               *
               * {BeaconProxy} will check that this address is a contract.
               */
              function implementation() external view returns (address);
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.0;
          /**
           * @dev Collection of functions related to the address type
           */
          library Address {
              /**
               * @dev Returns true if `account` is a contract.
               *
               * [IMPORTANT]
               * ====
               * It is unsafe to assume that an address for which this function returns
               * false is an externally-owned account (EOA) and not a contract.
               *
               * Among others, `isContract` will return false for the following
               * types of addresses:
               *
               *  - an externally-owned account
               *  - a contract in construction
               *  - an address where a contract will be created
               *  - an address where a contract lived, but was destroyed
               * ====
               */
              function isContract(address account) internal view returns (bool) {
                  // This method relies on extcodesize, which returns 0 for contracts in
                  // construction, since the code is only stored at the end of the
                  // constructor execution.
                  uint256 size;
                  // solhint-disable-next-line no-inline-assembly
                  assembly { size := extcodesize(account) }
                  return size > 0;
              }
              /**
               * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
               * `recipient`, forwarding all available gas and reverting on errors.
               *
               * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
               * of certain opcodes, possibly making contracts go over the 2300 gas limit
               * imposed by `transfer`, making them unable to receive funds via
               * `transfer`. {sendValue} removes this limitation.
               *
               * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
               *
               * IMPORTANT: because control is transferred to `recipient`, care must be
               * taken to not create reentrancy vulnerabilities. Consider using
               * {ReentrancyGuard} or the
               * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
               */
              function sendValue(address payable recipient, uint256 amount) internal {
                  require(address(this).balance >= amount, "Address: insufficient balance");
                  // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
                  (bool success, ) = recipient.call{ value: amount }("");
                  require(success, "Address: unable to send value, recipient may have reverted");
              }
              /**
               * @dev Performs a Solidity function call using a low level `call`. A
               * plain`call` is an unsafe replacement for a function call: use this
               * function instead.
               *
               * If `target` reverts with a revert reason, it is bubbled up by this
               * function (like regular Solidity function calls).
               *
               * Returns the raw returned data. To convert to the expected return value,
               * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
               *
               * Requirements:
               *
               * - `target` must be a contract.
               * - calling `target` with `data` must not revert.
               *
               * _Available since v3.1._
               */
              function functionCall(address target, bytes memory data) internal returns (bytes memory) {
                return functionCall(target, data, "Address: low-level call failed");
              }
              /**
               * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
               * `errorMessage` as a fallback revert reason when `target` reverts.
               *
               * _Available since v3.1._
               */
              function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
                  return functionCallWithValue(target, data, 0, errorMessage);
              }
              /**
               * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
               * but also transferring `value` wei to `target`.
               *
               * Requirements:
               *
               * - the calling contract must have an ETH balance of at least `value`.
               * - the called Solidity function must be `payable`.
               *
               * _Available since v3.1._
               */
              function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
                  return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
              }
              /**
               * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
               * with `errorMessage` as a fallback revert reason when `target` reverts.
               *
               * _Available since v3.1._
               */
              function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
                  require(address(this).balance >= value, "Address: insufficient balance for call");
                  require(isContract(target), "Address: call to non-contract");
                  // solhint-disable-next-line avoid-low-level-calls
                  (bool success, bytes memory returndata) = target.call{ value: value }(data);
                  return _verifyCallResult(success, returndata, errorMessage);
              }
              /**
               * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
               * but performing a static call.
               *
               * _Available since v3.3._
               */
              function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
                  return functionStaticCall(target, data, "Address: low-level static call failed");
              }
              /**
               * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
               * but performing a static call.
               *
               * _Available since v3.3._
               */
              function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
                  require(isContract(target), "Address: static call to non-contract");
                  // solhint-disable-next-line avoid-low-level-calls
                  (bool success, bytes memory returndata) = target.staticcall(data);
                  return _verifyCallResult(success, returndata, errorMessage);
              }
              /**
               * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
               * but performing a delegate call.
               *
               * _Available since v3.4._
               */
              function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
                  return functionDelegateCall(target, data, "Address: low-level delegate call failed");
              }
              /**
               * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
               * but performing a delegate call.
               *
               * _Available since v3.4._
               */
              function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
                  require(isContract(target), "Address: delegate call to non-contract");
                  // solhint-disable-next-line avoid-low-level-calls
                  (bool success, bytes memory returndata) = target.delegatecall(data);
                  return _verifyCallResult(success, returndata, errorMessage);
              }
              function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
                  if (success) {
                      return returndata;
                  } else {
                      // Look for revert reason and bubble it up if present
                      if (returndata.length > 0) {
                          // The easiest way to bubble the revert reason is using memory via assembly
                          // solhint-disable-next-line no-inline-assembly
                          assembly {
                              let returndata_size := mload(returndata)
                              revert(add(32, returndata), returndata_size)
                          }
                      } else {
                          revert(errorMessage);
                      }
                  }
              }
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.0;
          /**
           * @dev Library for reading and writing primitive types to specific storage slots.
           *
           * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
           * This library helps with reading and writing to such slots without the need for inline assembly.
           *
           * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
           *
           * Example usage to set ERC1967 implementation slot:
           * ```
           * contract ERC1967 {
           *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
           *
           *     function _getImplementation() internal view returns (address) {
           *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
           *     }
           *
           *     function _setImplementation(address newImplementation) internal {
           *         require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
           *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
           *     }
           * }
           * ```
           *
           * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._
           */
          library StorageSlot {
              struct AddressSlot {
                  address value;
              }
              struct BooleanSlot {
                  bool value;
              }
              struct Bytes32Slot {
                  bytes32 value;
              }
              struct Uint256Slot {
                  uint256 value;
              }
              /**
               * @dev Returns an `AddressSlot` with member `value` located at `slot`.
               */
              function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
                  assembly {
                      r.slot := slot
                  }
              }
              /**
               * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
               */
              function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
                  assembly {
                      r.slot := slot
                  }
              }
              /**
               * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
               */
              function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
                  assembly {
                      r.slot := slot
                  }
              }
              /**
               * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
               */
              function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
                  assembly {
                      r.slot := slot
                  }
              }
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.0;
          import "../utils/Context.sol";
          /**
           * @dev Contract module which provides a basic access control mechanism, where
           * there is an account (an owner) that can be granted exclusive access to
           * specific functions.
           *
           * By default, the owner account will be the one that deploys the contract. This
           * can later be changed with {transferOwnership}.
           *
           * This module is used through inheritance. It will make available the modifier
           * `onlyOwner`, which can be applied to your functions to restrict their use to
           * the owner.
           */
          abstract contract Ownable is Context {
              address private _owner;
              event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
              /**
               * @dev Initializes the contract setting the deployer as the initial owner.
               */
              constructor () {
                  address msgSender = _msgSender();
                  _owner = msgSender;
                  emit OwnershipTransferred(address(0), msgSender);
              }
              /**
               * @dev Returns the address of the current owner.
               */
              function owner() public view virtual returns (address) {
                  return _owner;
              }
              /**
               * @dev Throws if called by any account other than the owner.
               */
              modifier onlyOwner() {
                  require(owner() == _msgSender(), "Ownable: caller is not the owner");
                  _;
              }
              /**
               * @dev Leaves the contract without owner. It will not be possible to call
               * `onlyOwner` functions anymore. Can only be called by the current owner.
               *
               * NOTE: Renouncing ownership will leave the contract without an owner,
               * thereby removing any functionality that is only available to the owner.
               */
              function renounceOwnership() public virtual onlyOwner {
                  emit OwnershipTransferred(_owner, address(0));
                  _owner = address(0);
              }
              /**
               * @dev Transfers ownership of the contract to a new account (`newOwner`).
               * Can only be called by the current owner.
               */
              function transferOwnership(address newOwner) public virtual onlyOwner {
                  require(newOwner != address(0), "Ownable: new owner is the zero address");
                  emit OwnershipTransferred(_owner, newOwner);
                  _owner = newOwner;
              }
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.0;
          /*
           * @dev Provides information about the current execution context, including the
           * sender of the transaction and its data. While these are generally available
           * via msg.sender and msg.data, they should not be accessed in such a direct
           * manner, since when dealing with meta-transactions the account sending and
           * paying for execution may not be the actual sender (as far as an application
           * is concerned).
           *
           * This contract is only required for intermediate, library-like contracts.
           */
          abstract contract Context {
              function _msgSender() internal view virtual returns (address) {
                  return msg.sender;
              }
              function _msgData() internal view virtual returns (bytes calldata) {
                  this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
                  return msg.data;
              }
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.0;
          import "../ERC1967/ERC1967Upgrade.sol";
          /**
           * @dev Base contract for building openzeppelin-upgrades compatible implementations for the {ERC1967Proxy}. It includes
           * publicly available upgrade functions that are called by the plugin and by the secure upgrade mechanism to verify
           * continuation of the upgradability.
           *
           * The {_authorizeUpgrade} function MUST be overridden to include access restriction to the upgrade mechanism.
           *
           * _Available since v4.1._
           */
          abstract contract UUPSUpgradeable is ERC1967Upgrade {
              function upgradeTo(address newImplementation) external virtual {
                  _authorizeUpgrade(newImplementation);
                  _upgradeToAndCallSecure(newImplementation, bytes(""), false);
              }
              function upgradeToAndCall(address newImplementation, bytes memory data) external payable virtual {
                  _authorizeUpgrade(newImplementation);
                  _upgradeToAndCallSecure(newImplementation, data, true);
              }
              function _authorizeUpgrade(address newImplementation) internal virtual;
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.2;
          import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
          abstract contract Proxiable is UUPSUpgradeable {
              function _authorizeUpgrade(address newImplementation) internal override {
                  _beforeUpgrade(newImplementation);
              }
              function _beforeUpgrade(address newImplementation) internal virtual;
          }
          contract ChildOfProxiable is Proxiable {
              function _beforeUpgrade(address newImplementation) internal virtual override {}
          }
          

          File 3 of 5: Conduit
          // SPDX-License-Identifier: MIT
          pragma solidity >=0.8.7;
          import { ConduitInterface } from "../interfaces/ConduitInterface.sol";
          import { ConduitItemType } from "./lib/ConduitEnums.sol";
          import { TokenTransferrer } from "../lib/TokenTransferrer.sol";
          // prettier-ignore
          import {
              ConduitTransfer,
              ConduitBatch1155Transfer
          } from "./lib/ConduitStructs.sol";
          import "./lib/ConduitConstants.sol";
          /**
           * @title Conduit
           * @author 0age
           * @notice This contract serves as an originator for "proxied" transfers. Each
           *         conduit is deployed and controlled by a "conduit controller" that can
           *         add and remove "channels" or contracts that can instruct the conduit
           *         to transfer approved ERC20/721/1155 tokens. *IMPORTANT NOTE: each
           *         conduit has an owner that can arbitrarily add or remove channels, and
           *         a malicious or negligent owner can add a channel that allows for any
           *         approved ERC20/721/1155 tokens to be taken immediately — be extremely
           *         cautious with what conduits you give token approvals to!*
           */
          contract Conduit is ConduitInterface, TokenTransferrer {
              // Set deployer as an immutable controller that can update channel statuses.
              address private immutable _controller;
              // Track the status of each channel.
              mapping(address => bool) private _channels;
              /**
               * @notice Ensure that the caller is currently registered as an open channel
               *         on the conduit.
               */
              modifier onlyOpenChannel() {
                  // Utilize assembly to access channel storage mapping directly.
                  assembly {
                      // Write the caller to scratch space.
                      mstore(ChannelKey_channel_ptr, caller())
                      // Write the storage slot for _channels to scratch space.
                      mstore(ChannelKey_slot_ptr, _channels.slot)
                      // Derive the position in storage of _channels[msg.sender]
                      // and check if the stored value is zero.
                      if iszero(
                          sload(keccak256(ChannelKey_channel_ptr, ChannelKey_length))
                      ) {
                          // The caller is not an open channel; revert with
                          // ChannelClosed(caller). First, set error signature in memory.
                          mstore(ChannelClosed_error_ptr, ChannelClosed_error_signature)
                          // Next, set the caller as the argument.
                          mstore(ChannelClosed_channel_ptr, caller())
                          // Finally, revert, returning full custom error with argument.
                          revert(ChannelClosed_error_ptr, ChannelClosed_error_length)
                      }
                  }
                  // Continue with function execution.
                  _;
              }
              /**
               * @notice In the constructor, set the deployer as the controller.
               */
              constructor() {
                  // Set the deployer as the controller.
                  _controller = msg.sender;
              }
              /**
               * @notice Execute a sequence of ERC20/721/1155 transfers. Only a caller
               *         with an open channel can call this function. Note that channels
               *         are expected to implement reentrancy protection if desired, and
               *         that cross-channel reentrancy may be possible if the conduit has
               *         multiple open channels at once. Also note that channels are
               *         expected to implement checks against transferring any zero-amount
               *         items if that constraint is desired.
               *
               * @param transfers The ERC20/721/1155 transfers to perform.
               *
               * @return magicValue A magic value indicating that the transfers were
               *                    performed successfully.
               */
              function execute(ConduitTransfer[] calldata transfers)
                  external
                  override
                  onlyOpenChannel
                  returns (bytes4 magicValue)
              {
                  // Retrieve the total number of transfers and place on the stack.
                  uint256 totalStandardTransfers = transfers.length;
                  // Iterate over each transfer.
                  for (uint256 i = 0; i < totalStandardTransfers; ) {
                      // Retrieve the transfer in question and perform the transfer.
                      _transfer(transfers[i]);
                      // Skip overflow check as for loop is indexed starting at zero.
                      unchecked {
                          ++i;
                      }
                  }
                  // Return a magic value indicating that the transfers were performed.
                  magicValue = this.execute.selector;
              }
              /**
               * @notice Execute a sequence of batch 1155 item transfers. Only a caller
               *         with an open channel can call this function. Note that channels
               *         are expected to implement reentrancy protection if desired, and
               *         that cross-channel reentrancy may be possible if the conduit has
               *         multiple open channels at once. Also note that channels are
               *         expected to implement checks against transferring any zero-amount
               *         items if that constraint is desired.
               *
               * @param batchTransfers The 1155 batch item transfers to perform.
               *
               * @return magicValue A magic value indicating that the item transfers were
               *                    performed successfully.
               */
              function executeBatch1155(
                  ConduitBatch1155Transfer[] calldata batchTransfers
              ) external override onlyOpenChannel returns (bytes4 magicValue) {
                  // Perform 1155 batch transfers. Note that memory should be considered
                  // entirely corrupted from this point forward.
                  _performERC1155BatchTransfers(batchTransfers);
                  // Return a magic value indicating that the transfers were performed.
                  magicValue = this.executeBatch1155.selector;
              }
              /**
               * @notice Execute a sequence of transfers, both single ERC20/721/1155 item
               *         transfers as well as batch 1155 item transfers. Only a caller
               *         with an open channel can call this function. Note that channels
               *         are expected to implement reentrancy protection if desired, and
               *         that cross-channel reentrancy may be possible if the conduit has
               *         multiple open channels at once. Also note that channels are
               *         expected to implement checks against transferring any zero-amount
               *         items if that constraint is desired.
               *
               * @param standardTransfers The ERC20/721/1155 item transfers to perform.
               * @param batchTransfers    The 1155 batch item transfers to perform.
               *
               * @return magicValue A magic value indicating that the item transfers were
               *                    performed successfully.
               */
              function executeWithBatch1155(
                  ConduitTransfer[] calldata standardTransfers,
                  ConduitBatch1155Transfer[] calldata batchTransfers
              ) external override onlyOpenChannel returns (bytes4 magicValue) {
                  // Retrieve the total number of transfers and place on the stack.
                  uint256 totalStandardTransfers = standardTransfers.length;
                  // Iterate over each standard transfer.
                  for (uint256 i = 0; i < totalStandardTransfers; ) {
                      // Retrieve the transfer in question and perform the transfer.
                      _transfer(standardTransfers[i]);
                      // Skip overflow check as for loop is indexed starting at zero.
                      unchecked {
                          ++i;
                      }
                  }
                  // Perform 1155 batch transfers. Note that memory should be considered
                  // entirely corrupted from this point forward aside from the free memory
                  // pointer having the default value.
                  _performERC1155BatchTransfers(batchTransfers);
                  // Return a magic value indicating that the transfers were performed.
                  magicValue = this.executeWithBatch1155.selector;
              }
              /**
               * @notice Open or close a given channel. Only callable by the controller.
               *
               * @param channel The channel to open or close.
               * @param isOpen  The status of the channel (either open or closed).
               */
              function updateChannel(address channel, bool isOpen) external override {
                  // Ensure that the caller is the controller of this contract.
                  if (msg.sender != _controller) {
                      revert InvalidController();
                  }
                  // Ensure that the channel does not already have the indicated status.
                  if (_channels[channel] == isOpen) {
                      revert ChannelStatusAlreadySet(channel, isOpen);
                  }
                  // Update the status of the channel.
                  _channels[channel] = isOpen;
                  // Emit a corresponding event.
                  emit ChannelUpdated(channel, isOpen);
              }
              /**
               * @dev Internal function to transfer a given ERC20/721/1155 item. Note that
               *      channels are expected to implement checks against transferring any
               *      zero-amount items if that constraint is desired.
               *
               * @param item The ERC20/721/1155 item to transfer.
               */
              function _transfer(ConduitTransfer calldata item) internal {
                  // Determine the transfer method based on the respective item type.
                  if (item.itemType == ConduitItemType.ERC20) {
                      // Transfer ERC20 token. Note that item.identifier is ignored and
                      // therefore ERC20 transfer items are potentially malleable — this
                      // check should be performed by the calling channel if a constraint
                      // on item malleability is desired.
                      _performERC20Transfer(item.token, item.from, item.to, item.amount);
                  } else if (item.itemType == ConduitItemType.ERC721) {
                      // Ensure that exactly one 721 item is being transferred.
                      if (item.amount != 1) {
                          revert InvalidERC721TransferAmount();
                      }
                      // Transfer ERC721 token.
                      _performERC721Transfer(
                          item.token,
                          item.from,
                          item.to,
                          item.identifier
                      );
                  } else if (item.itemType == ConduitItemType.ERC1155) {
                      // Transfer ERC1155 token.
                      _performERC1155Transfer(
                          item.token,
                          item.from,
                          item.to,
                          item.identifier,
                          item.amount
                      );
                  } else {
                      // Throw with an error.
                      revert InvalidItemType();
                  }
              }
          }
          // SPDX-License-Identifier: MIT
          pragma solidity >=0.8.7;
          // prettier-ignore
          import {
              ConduitTransfer,
              ConduitBatch1155Transfer
          } from "../conduit/lib/ConduitStructs.sol";
          /**
           * @title ConduitInterface
           * @author 0age
           * @notice ConduitInterface contains all external function interfaces, events,
           *         and errors for conduit contracts.
           */
          interface ConduitInterface {
              /**
               * @dev Revert with an error when attempting to execute transfers using a
               *      caller that does not have an open channel.
               */
              error ChannelClosed(address channel);
              /**
               * @dev Revert with an error when attempting to update a channel to the
               *      current status of that channel.
               */
              error ChannelStatusAlreadySet(address channel, bool isOpen);
              /**
               * @dev Revert with an error when attempting to execute a transfer for an
               *      item that does not have an ERC20/721/1155 item type.
               */
              error InvalidItemType();
              /**
               * @dev Revert with an error when attempting to update the status of a
               *      channel from a caller that is not the conduit controller.
               */
              error InvalidController();
              /**
               * @dev Emit an event whenever a channel is opened or closed.
               *
               * @param channel The channel that has been updated.
               * @param open    A boolean indicating whether the conduit is open or not.
               */
              event ChannelUpdated(address indexed channel, bool open);
              /**
               * @notice Execute a sequence of ERC20/721/1155 transfers. Only a caller
               *         with an open channel can call this function.
               *
               * @param transfers The ERC20/721/1155 transfers to perform.
               *
               * @return magicValue A magic value indicating that the transfers were
               *                    performed successfully.
               */
              function execute(ConduitTransfer[] calldata transfers)
                  external
                  returns (bytes4 magicValue);
              /**
               * @notice Execute a sequence of batch 1155 transfers. Only a caller with an
               *         open channel can call this function.
               *
               * @param batch1155Transfers The 1155 batch transfers to perform.
               *
               * @return magicValue A magic value indicating that the transfers were
               *                    performed successfully.
               */
              function executeBatch1155(
                  ConduitBatch1155Transfer[] calldata batch1155Transfers
              ) external returns (bytes4 magicValue);
              /**
               * @notice Execute a sequence of transfers, both single and batch 1155. Only
               *         a caller with an open channel can call this function.
               *
               * @param standardTransfers  The ERC20/721/1155 transfers to perform.
               * @param batch1155Transfers The 1155 batch transfers to perform.
               *
               * @return magicValue A magic value indicating that the transfers were
               *                    performed successfully.
               */
              function executeWithBatch1155(
                  ConduitTransfer[] calldata standardTransfers,
                  ConduitBatch1155Transfer[] calldata batch1155Transfers
              ) external returns (bytes4 magicValue);
              /**
               * @notice Open or close a given channel. Only callable by the controller.
               *
               * @param channel The channel to open or close.
               * @param isOpen  The status of the channel (either open or closed).
               */
              function updateChannel(address channel, bool isOpen) external;
          }
          // SPDX-License-Identifier: MIT
          pragma solidity >=0.8.7;
          enum ConduitItemType {
              NATIVE, // unused
              ERC20,
              ERC721,
              ERC1155
          }
          // SPDX-License-Identifier: MIT
          pragma solidity >=0.8.7;
          import "./TokenTransferrerConstants.sol";
          // prettier-ignore
          import {
              TokenTransferrerErrors
          } from "../interfaces/TokenTransferrerErrors.sol";
          import { ConduitBatch1155Transfer } from "../conduit/lib/ConduitStructs.sol";
          /**
           * @title TokenTransferrer
           * @author 0age
           * @custom:coauthor d1ll0n
           * @custom:coauthor transmissions11
           * @notice TokenTransferrer is a library for performing optimized ERC20, ERC721,
           *         ERC1155, and batch ERC1155 transfers, used by both Seaport as well as
           *         by conduits deployed by the ConduitController. Use great caution when
           *         considering these functions for use in other codebases, as there are
           *         significant side effects and edge cases that need to be thoroughly
           *         understood and carefully addressed.
           */
          contract TokenTransferrer is TokenTransferrerErrors {
              /**
               * @dev Internal function to transfer ERC20 tokens from a given originator
               *      to a given recipient. Sufficient approvals must be set on the
               *      contract performing the transfer.
               *
               * @param token      The ERC20 token to transfer.
               * @param from       The originator of the transfer.
               * @param to         The recipient of the transfer.
               * @param amount     The amount to transfer.
               */
              function _performERC20Transfer(
                  address token,
                  address from,
                  address to,
                  uint256 amount
              ) internal {
                  // Utilize assembly to perform an optimized ERC20 token transfer.
                  assembly {
                      // The free memory pointer memory slot will be used when populating
                      // call data for the transfer; read the value and restore it later.
                      let memPointer := mload(FreeMemoryPointerSlot)
                      // Write call data into memory, starting with function selector.
                      mstore(ERC20_transferFrom_sig_ptr, ERC20_transferFrom_signature)
                      mstore(ERC20_transferFrom_from_ptr, from)
                      mstore(ERC20_transferFrom_to_ptr, to)
                      mstore(ERC20_transferFrom_amount_ptr, amount)
                      // Make call & copy up to 32 bytes of return data to scratch space.
                      // Scratch space does not need to be cleared ahead of time, as the
                      // subsequent check will ensure that either at least a full word of
                      // return data is received (in which case it will be overwritten) or
                      // that no data is received (in which case scratch space will be
                      // ignored) on a successful call to the given token.
                      let callStatus := call(
                          gas(),
                          token,
                          0,
                          ERC20_transferFrom_sig_ptr,
                          ERC20_transferFrom_length,
                          0,
                          OneWord
                      )
                      // Determine whether transfer was successful using status & result.
                      let success := and(
                          // Set success to whether the call reverted, if not check it
                          // either returned exactly 1 (can't just be non-zero data), or
                          // had no return data.
                          or(
                              and(eq(mload(0), 1), gt(returndatasize(), 31)),
                              iszero(returndatasize())
                          ),
                          callStatus
                      )
                      // Handle cases where either the transfer failed or no data was
                      // returned. Group these, as most transfers will succeed with data.
                      // Equivalent to `or(iszero(success), iszero(returndatasize()))`
                      // but after it's inverted for JUMPI this expression is cheaper.
                      if iszero(and(success, iszero(iszero(returndatasize())))) {
                          // If the token has no code or the transfer failed: Equivalent
                          // to `or(iszero(success), iszero(extcodesize(token)))` but
                          // after it's inverted for JUMPI this expression is cheaper.
                          if iszero(and(iszero(iszero(extcodesize(token))), success)) {
                              // If the transfer failed:
                              if iszero(success) {
                                  // If it was due to a revert:
                                  if iszero(callStatus) {
                                      // If it returned a message, bubble it up as long as
                                      // sufficient gas remains to do so:
                                      if returndatasize() {
                                          // Ensure that sufficient gas is available to
                                          // copy returndata while expanding memory where
                                          // necessary. Start by computing the word size
                                          // of returndata and allocated memory. Round up
                                          // to the nearest full word.
                                          let returnDataWords := div(
                                              add(returndatasize(), AlmostOneWord),
                                              OneWord
                                          )
                                          // Note: use the free memory pointer in place of
                                          // msize() to work around a Yul warning that
                                          // prevents accessing msize directly when the IR
                                          // pipeline is activated.
                                          let msizeWords := div(memPointer, OneWord)
                                          // Next, compute the cost of the returndatacopy.
                                          let cost := mul(CostPerWord, returnDataWords)
                                          // Then, compute cost of new memory allocation.
                                          if gt(returnDataWords, msizeWords) {
                                              cost := add(
                                                  cost,
                                                  add(
                                                      mul(
                                                          sub(
                                                              returnDataWords,
                                                              msizeWords
                                                          ),
                                                          CostPerWord
                                                      ),
                                                      div(
                                                          sub(
                                                              mul(
                                                                  returnDataWords,
                                                                  returnDataWords
                                                              ),
                                                              mul(msizeWords, msizeWords)
                                                          ),
                                                          MemoryExpansionCoefficient
                                                      )
                                                  )
                                              )
                                          }
                                          // Finally, add a small constant and compare to
                                          // gas remaining; bubble up the revert data if
                                          // enough gas is still available.
                                          if lt(add(cost, ExtraGasBuffer), gas()) {
                                              // Copy returndata to memory; overwrite
                                              // existing memory.
                                              returndatacopy(0, 0, returndatasize())
                                              // Revert, specifying memory region with
                                              // copied returndata.
                                              revert(0, returndatasize())
                                          }
                                      }
                                      // Otherwise revert with a generic error message.
                                      mstore(
                                          TokenTransferGenericFailure_error_sig_ptr,
                                          TokenTransferGenericFailure_error_signature
                                      )
                                      mstore(
                                          TokenTransferGenericFailure_error_token_ptr,
                                          token
                                      )
                                      mstore(
                                          TokenTransferGenericFailure_error_from_ptr,
                                          from
                                      )
                                      mstore(TokenTransferGenericFailure_error_to_ptr, to)
                                      mstore(TokenTransferGenericFailure_error_id_ptr, 0)
                                      mstore(
                                          TokenTransferGenericFailure_error_amount_ptr,
                                          amount
                                      )
                                      revert(
                                          TokenTransferGenericFailure_error_sig_ptr,
                                          TokenTransferGenericFailure_error_length
                                      )
                                  }
                                  // Otherwise revert with a message about the token
                                  // returning false or non-compliant return values.
                                  mstore(
                                      BadReturnValueFromERC20OnTransfer_error_sig_ptr,
                                      BadReturnValueFromERC20OnTransfer_error_signature
                                  )
                                  mstore(
                                      BadReturnValueFromERC20OnTransfer_error_token_ptr,
                                      token
                                  )
                                  mstore(
                                      BadReturnValueFromERC20OnTransfer_error_from_ptr,
                                      from
                                  )
                                  mstore(
                                      BadReturnValueFromERC20OnTransfer_error_to_ptr,
                                      to
                                  )
                                  mstore(
                                      BadReturnValueFromERC20OnTransfer_error_amount_ptr,
                                      amount
                                  )
                                  revert(
                                      BadReturnValueFromERC20OnTransfer_error_sig_ptr,
                                      BadReturnValueFromERC20OnTransfer_error_length
                                  )
                              }
                              // Otherwise, revert with error about token not having code:
                              mstore(NoContract_error_sig_ptr, NoContract_error_signature)
                              mstore(NoContract_error_token_ptr, token)
                              revert(NoContract_error_sig_ptr, NoContract_error_length)
                          }
                          // Otherwise, the token just returned no data despite the call
                          // having succeeded; no need to optimize for this as it's not
                          // technically ERC20 compliant.
                      }
                      // Restore the original free memory pointer.
                      mstore(FreeMemoryPointerSlot, memPointer)
                      // Restore the zero slot to zero.
                      mstore(ZeroSlot, 0)
                  }
              }
              /**
               * @dev Internal function to transfer an ERC721 token from a given
               *      originator to a given recipient. Sufficient approvals must be set on
               *      the contract performing the transfer. Note that this function does
               *      not check whether the receiver can accept the ERC721 token (i.e. it
               *      does not use `safeTransferFrom`).
               *
               * @param token      The ERC721 token to transfer.
               * @param from       The originator of the transfer.
               * @param to         The recipient of the transfer.
               * @param identifier The tokenId to transfer.
               */
              function _performERC721Transfer(
                  address token,
                  address from,
                  address to,
                  uint256 identifier
              ) internal {
                  // Utilize assembly to perform an optimized ERC721 token transfer.
                  assembly {
                      // If the token has no code, revert.
                      if iszero(extcodesize(token)) {
                          mstore(NoContract_error_sig_ptr, NoContract_error_signature)
                          mstore(NoContract_error_token_ptr, token)
                          revert(NoContract_error_sig_ptr, NoContract_error_length)
                      }
                      // The free memory pointer memory slot will be used when populating
                      // call data for the transfer; read the value and restore it later.
                      let memPointer := mload(FreeMemoryPointerSlot)
                      // Write call data to memory starting with function selector.
                      mstore(ERC721_transferFrom_sig_ptr, ERC721_transferFrom_signature)
                      mstore(ERC721_transferFrom_from_ptr, from)
                      mstore(ERC721_transferFrom_to_ptr, to)
                      mstore(ERC721_transferFrom_id_ptr, identifier)
                      // Perform the call, ignoring return data.
                      let success := call(
                          gas(),
                          token,
                          0,
                          ERC721_transferFrom_sig_ptr,
                          ERC721_transferFrom_length,
                          0,
                          0
                      )
                      // If the transfer reverted:
                      if iszero(success) {
                          // If it returned a message, bubble it up as long as sufficient
                          // gas remains to do so:
                          if returndatasize() {
                              // Ensure that sufficient gas is available to copy
                              // returndata while expanding memory where necessary. Start
                              // by computing word size of returndata & allocated memory.
                              // Round up to the nearest full word.
                              let returnDataWords := div(
                                  add(returndatasize(), AlmostOneWord),
                                  OneWord
                              )
                              // Note: use the free memory pointer in place of msize() to
                              // work around a Yul warning that prevents accessing msize
                              // directly when the IR pipeline is activated.
                              let msizeWords := div(memPointer, OneWord)
                              // Next, compute the cost of the returndatacopy.
                              let cost := mul(CostPerWord, returnDataWords)
                              // Then, compute cost of new memory allocation.
                              if gt(returnDataWords, msizeWords) {
                                  cost := add(
                                      cost,
                                      add(
                                          mul(
                                              sub(returnDataWords, msizeWords),
                                              CostPerWord
                                          ),
                                          div(
                                              sub(
                                                  mul(returnDataWords, returnDataWords),
                                                  mul(msizeWords, msizeWords)
                                              ),
                                              MemoryExpansionCoefficient
                                          )
                                      )
                                  )
                              }
                              // Finally, add a small constant and compare to gas
                              // remaining; bubble up the revert data if enough gas is
                              // still available.
                              if lt(add(cost, ExtraGasBuffer), gas()) {
                                  // Copy returndata to memory; overwrite existing memory.
                                  returndatacopy(0, 0, returndatasize())
                                  // Revert, giving memory region with copied returndata.
                                  revert(0, returndatasize())
                              }
                          }
                          // Otherwise revert with a generic error message.
                          mstore(
                              TokenTransferGenericFailure_error_sig_ptr,
                              TokenTransferGenericFailure_error_signature
                          )
                          mstore(TokenTransferGenericFailure_error_token_ptr, token)
                          mstore(TokenTransferGenericFailure_error_from_ptr, from)
                          mstore(TokenTransferGenericFailure_error_to_ptr, to)
                          mstore(TokenTransferGenericFailure_error_id_ptr, identifier)
                          mstore(TokenTransferGenericFailure_error_amount_ptr, 1)
                          revert(
                              TokenTransferGenericFailure_error_sig_ptr,
                              TokenTransferGenericFailure_error_length
                          )
                      }
                      // Restore the original free memory pointer.
                      mstore(FreeMemoryPointerSlot, memPointer)
                      // Restore the zero slot to zero.
                      mstore(ZeroSlot, 0)
                  }
              }
              /**
               * @dev Internal function to transfer ERC1155 tokens from a given
               *      originator to a given recipient. Sufficient approvals must be set on
               *      the contract performing the transfer and contract recipients must
               *      implement the ERC1155TokenReceiver interface to indicate that they
               *      are willing to accept the transfer.
               *
               * @param token      The ERC1155 token to transfer.
               * @param from       The originator of the transfer.
               * @param to         The recipient of the transfer.
               * @param identifier The id to transfer.
               * @param amount     The amount to transfer.
               */
              function _performERC1155Transfer(
                  address token,
                  address from,
                  address to,
                  uint256 identifier,
                  uint256 amount
              ) internal {
                  // Utilize assembly to perform an optimized ERC1155 token transfer.
                  assembly {
                      // If the token has no code, revert.
                      if iszero(extcodesize(token)) {
                          mstore(NoContract_error_sig_ptr, NoContract_error_signature)
                          mstore(NoContract_error_token_ptr, token)
                          revert(NoContract_error_sig_ptr, NoContract_error_length)
                      }
                      // The following memory slots will be used when populating call data
                      // for the transfer; read the values and restore them later.
                      let memPointer := mload(FreeMemoryPointerSlot)
                      let slot0x80 := mload(Slot0x80)
                      let slot0xA0 := mload(Slot0xA0)
                      let slot0xC0 := mload(Slot0xC0)
                      // Write call data into memory, beginning with function selector.
                      mstore(
                          ERC1155_safeTransferFrom_sig_ptr,
                          ERC1155_safeTransferFrom_signature
                      )
                      mstore(ERC1155_safeTransferFrom_from_ptr, from)
                      mstore(ERC1155_safeTransferFrom_to_ptr, to)
                      mstore(ERC1155_safeTransferFrom_id_ptr, identifier)
                      mstore(ERC1155_safeTransferFrom_amount_ptr, amount)
                      mstore(
                          ERC1155_safeTransferFrom_data_offset_ptr,
                          ERC1155_safeTransferFrom_data_length_offset
                      )
                      mstore(ERC1155_safeTransferFrom_data_length_ptr, 0)
                      // Perform the call, ignoring return data.
                      let success := call(
                          gas(),
                          token,
                          0,
                          ERC1155_safeTransferFrom_sig_ptr,
                          ERC1155_safeTransferFrom_length,
                          0,
                          0
                      )
                      // If the transfer reverted:
                      if iszero(success) {
                          // If it returned a message, bubble it up as long as sufficient
                          // gas remains to do so:
                          if returndatasize() {
                              // Ensure that sufficient gas is available to copy
                              // returndata while expanding memory where necessary. Start
                              // by computing word size of returndata & allocated memory.
                              // Round up to the nearest full word.
                              let returnDataWords := div(
                                  add(returndatasize(), AlmostOneWord),
                                  OneWord
                              )
                              // Note: use the free memory pointer in place of msize() to
                              // work around a Yul warning that prevents accessing msize
                              // directly when the IR pipeline is activated.
                              let msizeWords := div(memPointer, OneWord)
                              // Next, compute the cost of the returndatacopy.
                              let cost := mul(CostPerWord, returnDataWords)
                              // Then, compute cost of new memory allocation.
                              if gt(returnDataWords, msizeWords) {
                                  cost := add(
                                      cost,
                                      add(
                                          mul(
                                              sub(returnDataWords, msizeWords),
                                              CostPerWord
                                          ),
                                          div(
                                              sub(
                                                  mul(returnDataWords, returnDataWords),
                                                  mul(msizeWords, msizeWords)
                                              ),
                                              MemoryExpansionCoefficient
                                          )
                                      )
                                  )
                              }
                              // Finally, add a small constant and compare to gas
                              // remaining; bubble up the revert data if enough gas is
                              // still available.
                              if lt(add(cost, ExtraGasBuffer), gas()) {
                                  // Copy returndata to memory; overwrite existing memory.
                                  returndatacopy(0, 0, returndatasize())
                                  // Revert, giving memory region with copied returndata.
                                  revert(0, returndatasize())
                              }
                          }
                          // Otherwise revert with a generic error message.
                          mstore(
                              TokenTransferGenericFailure_error_sig_ptr,
                              TokenTransferGenericFailure_error_signature
                          )
                          mstore(TokenTransferGenericFailure_error_token_ptr, token)
                          mstore(TokenTransferGenericFailure_error_from_ptr, from)
                          mstore(TokenTransferGenericFailure_error_to_ptr, to)
                          mstore(TokenTransferGenericFailure_error_id_ptr, identifier)
                          mstore(TokenTransferGenericFailure_error_amount_ptr, amount)
                          revert(
                              TokenTransferGenericFailure_error_sig_ptr,
                              TokenTransferGenericFailure_error_length
                          )
                      }
                      mstore(Slot0x80, slot0x80) // Restore slot 0x80.
                      mstore(Slot0xA0, slot0xA0) // Restore slot 0xA0.
                      mstore(Slot0xC0, slot0xC0) // Restore slot 0xC0.
                      // Restore the original free memory pointer.
                      mstore(FreeMemoryPointerSlot, memPointer)
                      // Restore the zero slot to zero.
                      mstore(ZeroSlot, 0)
                  }
              }
              /**
               * @dev Internal function to transfer ERC1155 tokens from a given
               *      originator to a given recipient. Sufficient approvals must be set on
               *      the contract performing the transfer and contract recipients must
               *      implement the ERC1155TokenReceiver interface to indicate that they
               *      are willing to accept the transfer. NOTE: this function is not
               *      memory-safe; it will overwrite existing memory, restore the free
               *      memory pointer to the default value, and overwrite the zero slot.
               *      This function should only be called once memory is no longer
               *      required and when uninitialized arrays are not utilized, and memory
               *      should be considered fully corrupted (aside from the existence of a
               *      default-value free memory pointer) after calling this function.
               *
               * @param batchTransfers The group of 1155 batch transfers to perform.
               */
              function _performERC1155BatchTransfers(
                  ConduitBatch1155Transfer[] calldata batchTransfers
              ) internal {
                  // Utilize assembly to perform optimized batch 1155 transfers.
                  assembly {
                      let len := batchTransfers.length
                      // Pointer to first head in the array, which is offset to the struct
                      // at each index. This gets incremented after each loop to avoid
                      // multiplying by 32 to get the offset for each element.
                      let nextElementHeadPtr := batchTransfers.offset
                      // Pointer to beginning of the head of the array. This is the
                      // reference position each offset references. It's held static to
                      // let each loop calculate the data position for an element.
                      let arrayHeadPtr := nextElementHeadPtr
                      // Write the function selector, which will be reused for each call:
                      // safeBatchTransferFrom(address,address,uint256[],uint256[],bytes)
                      mstore(
                          ConduitBatch1155Transfer_from_offset,
                          ERC1155_safeBatchTransferFrom_signature
                      )
                      // Iterate over each batch transfer.
                      for {
                          let i := 0
                      } lt(i, len) {
                          i := add(i, 1)
                      } {
                          // Read the offset to the beginning of the element and add
                          // it to pointer to the beginning of the array head to get
                          // the absolute position of the element in calldata.
                          let elementPtr := add(
                              arrayHeadPtr,
                              calldataload(nextElementHeadPtr)
                          )
                          // Retrieve the token from calldata.
                          let token := calldataload(elementPtr)
                          // If the token has no code, revert.
                          if iszero(extcodesize(token)) {
                              mstore(NoContract_error_sig_ptr, NoContract_error_signature)
                              mstore(NoContract_error_token_ptr, token)
                              revert(NoContract_error_sig_ptr, NoContract_error_length)
                          }
                          // Get the total number of supplied ids.
                          let idsLength := calldataload(
                              add(elementPtr, ConduitBatch1155Transfer_ids_length_offset)
                          )
                          // Determine the expected offset for the amounts array.
                          let expectedAmountsOffset := add(
                              ConduitBatch1155Transfer_amounts_length_baseOffset,
                              mul(idsLength, OneWord)
                          )
                          // Validate struct encoding.
                          let invalidEncoding := iszero(
                              and(
                                  // ids.length == amounts.length
                                  eq(
                                      idsLength,
                                      calldataload(add(elementPtr, expectedAmountsOffset))
                                  ),
                                  and(
                                      // ids_offset == 0xa0
                                      eq(
                                          calldataload(
                                              add(
                                                  elementPtr,
                                                  ConduitBatch1155Transfer_ids_head_offset
                                              )
                                          ),
                                          ConduitBatch1155Transfer_ids_length_offset
                                      ),
                                      // amounts_offset == 0xc0 + ids.length*32
                                      eq(
                                          calldataload(
                                              add(
                                                  elementPtr,
                                                  ConduitBatchTransfer_amounts_head_offset
                                              )
                                          ),
                                          expectedAmountsOffset
                                      )
                                  )
                              )
                          )
                          // Revert with an error if the encoding is not valid.
                          if invalidEncoding {
                              mstore(
                                  Invalid1155BatchTransferEncoding_ptr,
                                  Invalid1155BatchTransferEncoding_selector
                              )
                              revert(
                                  Invalid1155BatchTransferEncoding_ptr,
                                  Invalid1155BatchTransferEncoding_length
                              )
                          }
                          // Update the offset position for the next loop
                          nextElementHeadPtr := add(nextElementHeadPtr, OneWord)
                          // Copy the first section of calldata (before dynamic values).
                          calldatacopy(
                              BatchTransfer1155Params_ptr,
                              add(elementPtr, ConduitBatch1155Transfer_from_offset),
                              ConduitBatch1155Transfer_usable_head_size
                          )
                          // Determine size of calldata required for ids and amounts. Note
                          // that the size includes both lengths as well as the data.
                          let idsAndAmountsSize := add(TwoWords, mul(idsLength, TwoWords))
                          // Update the offset for the data array in memory.
                          mstore(
                              BatchTransfer1155Params_data_head_ptr,
                              add(
                                  BatchTransfer1155Params_ids_length_offset,
                                  idsAndAmountsSize
                              )
                          )
                          // Set the length of the data array in memory to zero.
                          mstore(
                              add(
                                  BatchTransfer1155Params_data_length_basePtr,
                                  idsAndAmountsSize
                              ),
                              0
                          )
                          // Determine the total calldata size for the call to transfer.
                          let transferDataSize := add(
                              BatchTransfer1155Params_calldata_baseSize,
                              idsAndAmountsSize
                          )
                          // Copy second section of calldata (including dynamic values).
                          calldatacopy(
                              BatchTransfer1155Params_ids_length_ptr,
                              add(elementPtr, ConduitBatch1155Transfer_ids_length_offset),
                              idsAndAmountsSize
                          )
                          // Perform the call to transfer 1155 tokens.
                          let success := call(
                              gas(),
                              token,
                              0,
                              ConduitBatch1155Transfer_from_offset, // Data portion start.
                              transferDataSize, // Location of the length of callData.
                              0,
                              0
                          )
                          // If the transfer reverted:
                          if iszero(success) {
                              // If it returned a message, bubble it up as long as
                              // sufficient gas remains to do so:
                              if returndatasize() {
                                  // Ensure that sufficient gas is available to copy
                                  // returndata while expanding memory where necessary.
                                  // Start by computing word size of returndata and
                                  // allocated memory. Round up to the nearest full word.
                                  let returnDataWords := div(
                                      add(returndatasize(), AlmostOneWord),
                                      OneWord
                                  )
                                  // Note: use transferDataSize in place of msize() to
                                  // work around a Yul warning that prevents accessing
                                  // msize directly when the IR pipeline is activated.
                                  // The free memory pointer is not used here because
                                  // this function does almost all memory management
                                  // manually and does not update it, and transferDataSize
                                  // should be the largest memory value used (unless a
                                  // previous batch was larger).
                                  let msizeWords := div(transferDataSize, OneWord)
                                  // Next, compute the cost of the returndatacopy.
                                  let cost := mul(CostPerWord, returnDataWords)
                                  // Then, compute cost of new memory allocation.
                                  if gt(returnDataWords, msizeWords) {
                                      cost := add(
                                          cost,
                                          add(
                                              mul(
                                                  sub(returnDataWords, msizeWords),
                                                  CostPerWord
                                              ),
                                              div(
                                                  sub(
                                                      mul(
                                                          returnDataWords,
                                                          returnDataWords
                                                      ),
                                                      mul(msizeWords, msizeWords)
                                                  ),
                                                  MemoryExpansionCoefficient
                                              )
                                          )
                                      )
                                  }
                                  // Finally, add a small constant and compare to gas
                                  // remaining; bubble up the revert data if enough gas is
                                  // still available.
                                  if lt(add(cost, ExtraGasBuffer), gas()) {
                                      // Copy returndata to memory; overwrite existing.
                                      returndatacopy(0, 0, returndatasize())
                                      // Revert with memory region containing returndata.
                                      revert(0, returndatasize())
                                  }
                              }
                              // Set the error signature.
                              mstore(
                                  0,
                                  ERC1155BatchTransferGenericFailure_error_signature
                              )
                              // Write the token.
                              mstore(ERC1155BatchTransferGenericFailure_token_ptr, token)
                              // Increase the offset to ids by 32.
                              mstore(
                                  BatchTransfer1155Params_ids_head_ptr,
                                  ERC1155BatchTransferGenericFailure_ids_offset
                              )
                              // Increase the offset to amounts by 32.
                              mstore(
                                  BatchTransfer1155Params_amounts_head_ptr,
                                  add(
                                      OneWord,
                                      mload(BatchTransfer1155Params_amounts_head_ptr)
                                  )
                              )
                              // Return modified region. The total size stays the same as
                              // `token` uses the same number of bytes as `data.length`.
                              revert(0, transferDataSize)
                          }
                      }
                      // Reset the free memory pointer to the default value; memory must
                      // be assumed to be dirtied and not reused from this point forward.
                      // Also note that the zero slot is not reset to zero, meaning empty
                      // arrays cannot be safely created or utilized until it is restored.
                      mstore(FreeMemoryPointerSlot, DefaultFreeMemoryPointer)
                  }
              }
          }
          // SPDX-License-Identifier: MIT
          pragma solidity >=0.8.7;
          import { ConduitItemType } from "./ConduitEnums.sol";
          struct ConduitTransfer {
              ConduitItemType itemType;
              address token;
              address from;
              address to;
              uint256 identifier;
              uint256 amount;
          }
          struct ConduitBatch1155Transfer {
              address token;
              address from;
              address to;
              uint256[] ids;
              uint256[] amounts;
          }
          // SPDX-License-Identifier: MIT
          pragma solidity >=0.8.7;
          // error ChannelClosed(address channel)
          uint256 constant ChannelClosed_error_signature = (
              0x93daadf200000000000000000000000000000000000000000000000000000000
          );
          uint256 constant ChannelClosed_error_ptr = 0x00;
          uint256 constant ChannelClosed_channel_ptr = 0x4;
          uint256 constant ChannelClosed_error_length = 0x24;
          // For the mapping:
          // mapping(address => bool) channels
          // The position in storage for a particular account is:
          // keccak256(abi.encode(account, channels.slot))
          uint256 constant ChannelKey_channel_ptr = 0x00;
          uint256 constant ChannelKey_slot_ptr = 0x20;
          uint256 constant ChannelKey_length = 0x40;
          // SPDX-License-Identifier: MIT
          pragma solidity >=0.8.7;
          /*
           * -------------------------- Disambiguation & Other Notes ---------------------
           *    - The term "head" is used as it is in the documentation for ABI encoding,
           *      but only in reference to dynamic types, i.e. it always refers to the
           *      offset or pointer to the body of a dynamic type. In calldata, the head
           *      is always an offset (relative to the parent object), while in memory,
           *      the head is always the pointer to the body. More information found here:
           *      https://docs.soliditylang.org/en/v0.8.14/abi-spec.html#argument-encoding
           *        - Note that the length of an array is separate from and precedes the
           *          head of the array.
           *
           *    - The term "body" is used in place of the term "head" used in the ABI
           *      documentation. It refers to the start of the data for a dynamic type,
           *      e.g. the first word of a struct or the first word of the first element
           *      in an array.
           *
           *    - The term "pointer" is used to describe the absolute position of a value
           *      and never an offset relative to another value.
           *        - The suffix "_ptr" refers to a memory pointer.
           *        - The suffix "_cdPtr" refers to a calldata pointer.
           *
           *    - The term "offset" is used to describe the position of a value relative
           *      to some parent value. For example, OrderParameters_conduit_offset is the
           *      offset to the "conduit" value in the OrderParameters struct relative to
           *      the start of the body.
           *        - Note: Offsets are used to derive pointers.
           *
           *    - Some structs have pointers defined for all of their fields in this file.
           *      Lines which are commented out are fields that are not used in the
           *      codebase but have been left in for readability.
           */
          uint256 constant AlmostOneWord = 0x1f;
          uint256 constant OneWord = 0x20;
          uint256 constant TwoWords = 0x40;
          uint256 constant ThreeWords = 0x60;
          uint256 constant FreeMemoryPointerSlot = 0x40;
          uint256 constant ZeroSlot = 0x60;
          uint256 constant DefaultFreeMemoryPointer = 0x80;
          uint256 constant Slot0x80 = 0x80;
          uint256 constant Slot0xA0 = 0xa0;
          uint256 constant Slot0xC0 = 0xc0;
          // abi.encodeWithSignature("transferFrom(address,address,uint256)")
          uint256 constant ERC20_transferFrom_signature = (
              0x23b872dd00000000000000000000000000000000000000000000000000000000
          );
          uint256 constant ERC20_transferFrom_sig_ptr = 0x0;
          uint256 constant ERC20_transferFrom_from_ptr = 0x04;
          uint256 constant ERC20_transferFrom_to_ptr = 0x24;
          uint256 constant ERC20_transferFrom_amount_ptr = 0x44;
          uint256 constant ERC20_transferFrom_length = 0x64; // 4 + 32 * 3 == 100
          // abi.encodeWithSignature(
          //     "safeTransferFrom(address,address,uint256,uint256,bytes)"
          // )
          uint256 constant ERC1155_safeTransferFrom_signature = (
              0xf242432a00000000000000000000000000000000000000000000000000000000
          );
          uint256 constant ERC1155_safeTransferFrom_sig_ptr = 0x0;
          uint256 constant ERC1155_safeTransferFrom_from_ptr = 0x04;
          uint256 constant ERC1155_safeTransferFrom_to_ptr = 0x24;
          uint256 constant ERC1155_safeTransferFrom_id_ptr = 0x44;
          uint256 constant ERC1155_safeTransferFrom_amount_ptr = 0x64;
          uint256 constant ERC1155_safeTransferFrom_data_offset_ptr = 0x84;
          uint256 constant ERC1155_safeTransferFrom_data_length_ptr = 0xa4;
          uint256 constant ERC1155_safeTransferFrom_length = 0xc4; // 4 + 32 * 6 == 196
          uint256 constant ERC1155_safeTransferFrom_data_length_offset = 0xa0;
          // abi.encodeWithSignature(
          //     "safeBatchTransferFrom(address,address,uint256[],uint256[],bytes)"
          // )
          uint256 constant ERC1155_safeBatchTransferFrom_signature = (
              0x2eb2c2d600000000000000000000000000000000000000000000000000000000
          );
          bytes4 constant ERC1155_safeBatchTransferFrom_selector = bytes4(
              bytes32(ERC1155_safeBatchTransferFrom_signature)
          );
          uint256 constant ERC721_transferFrom_signature = ERC20_transferFrom_signature;
          uint256 constant ERC721_transferFrom_sig_ptr = 0x0;
          uint256 constant ERC721_transferFrom_from_ptr = 0x04;
          uint256 constant ERC721_transferFrom_to_ptr = 0x24;
          uint256 constant ERC721_transferFrom_id_ptr = 0x44;
          uint256 constant ERC721_transferFrom_length = 0x64; // 4 + 32 * 3 == 100
          // abi.encodeWithSignature("NoContract(address)")
          uint256 constant NoContract_error_signature = (
              0x5f15d67200000000000000000000000000000000000000000000000000000000
          );
          uint256 constant NoContract_error_sig_ptr = 0x0;
          uint256 constant NoContract_error_token_ptr = 0x4;
          uint256 constant NoContract_error_length = 0x24; // 4 + 32 == 36
          // abi.encodeWithSignature(
          //     "TokenTransferGenericFailure(address,address,address,uint256,uint256)"
          // )
          uint256 constant TokenTransferGenericFailure_error_signature = (
              0xf486bc8700000000000000000000000000000000000000000000000000000000
          );
          uint256 constant TokenTransferGenericFailure_error_sig_ptr = 0x0;
          uint256 constant TokenTransferGenericFailure_error_token_ptr = 0x4;
          uint256 constant TokenTransferGenericFailure_error_from_ptr = 0x24;
          uint256 constant TokenTransferGenericFailure_error_to_ptr = 0x44;
          uint256 constant TokenTransferGenericFailure_error_id_ptr = 0x64;
          uint256 constant TokenTransferGenericFailure_error_amount_ptr = 0x84;
          // 4 + 32 * 5 == 164
          uint256 constant TokenTransferGenericFailure_error_length = 0xa4;
          // abi.encodeWithSignature(
          //     "BadReturnValueFromERC20OnTransfer(address,address,address,uint256)"
          // )
          uint256 constant BadReturnValueFromERC20OnTransfer_error_signature = (
              0x9889192300000000000000000000000000000000000000000000000000000000
          );
          uint256 constant BadReturnValueFromERC20OnTransfer_error_sig_ptr = 0x0;
          uint256 constant BadReturnValueFromERC20OnTransfer_error_token_ptr = 0x4;
          uint256 constant BadReturnValueFromERC20OnTransfer_error_from_ptr = 0x24;
          uint256 constant BadReturnValueFromERC20OnTransfer_error_to_ptr = 0x44;
          uint256 constant BadReturnValueFromERC20OnTransfer_error_amount_ptr = 0x64;
          // 4 + 32 * 4 == 132
          uint256 constant BadReturnValueFromERC20OnTransfer_error_length = 0x84;
          uint256 constant ExtraGasBuffer = 0x20;
          uint256 constant CostPerWord = 3;
          uint256 constant MemoryExpansionCoefficient = 0x200;
          // Values are offset by 32 bytes in order to write the token to the beginning
          // in the event of a revert
          uint256 constant BatchTransfer1155Params_ptr = 0x24;
          uint256 constant BatchTransfer1155Params_ids_head_ptr = 0x64;
          uint256 constant BatchTransfer1155Params_amounts_head_ptr = 0x84;
          uint256 constant BatchTransfer1155Params_data_head_ptr = 0xa4;
          uint256 constant BatchTransfer1155Params_data_length_basePtr = 0xc4;
          uint256 constant BatchTransfer1155Params_calldata_baseSize = 0xc4;
          uint256 constant BatchTransfer1155Params_ids_length_ptr = 0xc4;
          uint256 constant BatchTransfer1155Params_ids_length_offset = 0xa0;
          uint256 constant BatchTransfer1155Params_amounts_length_baseOffset = 0xc0;
          uint256 constant BatchTransfer1155Params_data_length_baseOffset = 0xe0;
          uint256 constant ConduitBatch1155Transfer_usable_head_size = 0x80;
          uint256 constant ConduitBatch1155Transfer_from_offset = 0x20;
          uint256 constant ConduitBatch1155Transfer_ids_head_offset = 0x60;
          uint256 constant ConduitBatch1155Transfer_amounts_head_offset = 0x80;
          uint256 constant ConduitBatch1155Transfer_ids_length_offset = 0xa0;
          uint256 constant ConduitBatch1155Transfer_amounts_length_baseOffset = 0xc0;
          uint256 constant ConduitBatch1155Transfer_calldata_baseSize = 0xc0;
          // Note: abbreviated version of above constant to adhere to line length limit.
          uint256 constant ConduitBatchTransfer_amounts_head_offset = 0x80;
          uint256 constant Invalid1155BatchTransferEncoding_ptr = 0x00;
          uint256 constant Invalid1155BatchTransferEncoding_length = 0x04;
          uint256 constant Invalid1155BatchTransferEncoding_selector = (
              0xeba2084c00000000000000000000000000000000000000000000000000000000
          );
          uint256 constant ERC1155BatchTransferGenericFailure_error_signature = (
              0xafc445e200000000000000000000000000000000000000000000000000000000
          );
          uint256 constant ERC1155BatchTransferGenericFailure_token_ptr = 0x04;
          uint256 constant ERC1155BatchTransferGenericFailure_ids_offset = 0xc0;
          // SPDX-License-Identifier: MIT
          pragma solidity >=0.8.7;
          /**
           * @title TokenTransferrerErrors
           */
          interface TokenTransferrerErrors {
              /**
               * @dev Revert with an error when an ERC721 transfer with amount other than
               *      one is attempted.
               */
              error InvalidERC721TransferAmount();
              /**
               * @dev Revert with an error when attempting to fulfill an order where an
               *      item has an amount of zero.
               */
              error MissingItemAmount();
              /**
               * @dev Revert with an error when attempting to fulfill an order where an
               *      item has unused parameters. This includes both the token and the
               *      identifier parameters for native transfers as well as the identifier
               *      parameter for ERC20 transfers. Note that the conduit does not
               *      perform this check, leaving it up to the calling channel to enforce
               *      when desired.
               */
              error UnusedItemParameters();
              /**
               * @dev Revert with an error when an ERC20, ERC721, or ERC1155 token
               *      transfer reverts.
               *
               * @param token      The token for which the transfer was attempted.
               * @param from       The source of the attempted transfer.
               * @param to         The recipient of the attempted transfer.
               * @param identifier The identifier for the attempted transfer.
               * @param amount     The amount for the attempted transfer.
               */
              error TokenTransferGenericFailure(
                  address token,
                  address from,
                  address to,
                  uint256 identifier,
                  uint256 amount
              );
              /**
               * @dev Revert with an error when a batch ERC1155 token transfer reverts.
               *
               * @param token       The token for which the transfer was attempted.
               * @param from        The source of the attempted transfer.
               * @param to          The recipient of the attempted transfer.
               * @param identifiers The identifiers for the attempted transfer.
               * @param amounts     The amounts for the attempted transfer.
               */
              error ERC1155BatchTransferGenericFailure(
                  address token,
                  address from,
                  address to,
                  uint256[] identifiers,
                  uint256[] amounts
              );
              /**
               * @dev Revert with an error when an ERC20 token transfer returns a falsey
               *      value.
               *
               * @param token      The token for which the ERC20 transfer was attempted.
               * @param from       The source of the attempted ERC20 transfer.
               * @param to         The recipient of the attempted ERC20 transfer.
               * @param amount     The amount for the attempted ERC20 transfer.
               */
              error BadReturnValueFromERC20OnTransfer(
                  address token,
                  address from,
                  address to,
                  uint256 amount
              );
              /**
               * @dev Revert with an error when an account being called as an assumed
               *      contract does not have code and returns no data.
               *
               * @param account The account that should contain code.
               */
              error NoContract(address account);
              /**
               * @dev Revert with an error when attempting to execute an 1155 batch
               *      transfer using calldata not produced by default ABI encoding or with
               *      different lengths for ids and amounts arrays.
               */
              error Invalid1155BatchTransferEncoding();
          }
          

          File 4 of 5: Captainz
          // SPDX-License-Identifier: MIT
          // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
          pragma solidity ^0.8.0;
          import "../utils/ContextUpgradeable.sol";
          import "../proxy/utils/Initializable.sol";
          /**
           * @dev Contract module which provides a basic access control mechanism, where
           * there is an account (an owner) that can be granted exclusive access to
           * specific functions.
           *
           * By default, the owner account will be the one that deploys the contract. This
           * can later be changed with {transferOwnership}.
           *
           * This module is used through inheritance. It will make available the modifier
           * `onlyOwner`, which can be applied to your functions to restrict their use to
           * the owner.
           */
          abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
              address private _owner;
              event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
              /**
               * @dev Initializes the contract setting the deployer as the initial owner.
               */
              function __Ownable_init() internal onlyInitializing {
                  __Ownable_init_unchained();
              }
              function __Ownable_init_unchained() internal onlyInitializing {
                  _transferOwnership(_msgSender());
              }
              /**
               * @dev Throws if called by any account other than the owner.
               */
              modifier onlyOwner() {
                  _checkOwner();
                  _;
              }
              /**
               * @dev Returns the address of the current owner.
               */
              function owner() public view virtual returns (address) {
                  return _owner;
              }
              /**
               * @dev Throws if the sender is not the owner.
               */
              function _checkOwner() internal view virtual {
                  require(owner() == _msgSender(), "Ownable: caller is not the owner");
              }
              /**
               * @dev Leaves the contract without owner. It will not be possible to call
               * `onlyOwner` functions anymore. Can only be called by the current owner.
               *
               * NOTE: Renouncing ownership will leave the contract without an owner,
               * thereby removing any functionality that is only available to the owner.
               */
              function renounceOwnership() public virtual onlyOwner {
                  _transferOwnership(address(0));
              }
              /**
               * @dev Transfers ownership of the contract to a new account (`newOwner`).
               * Can only be called by the current owner.
               */
              function transferOwnership(address newOwner) public virtual onlyOwner {
                  require(newOwner != address(0), "Ownable: new owner is the zero address");
                  _transferOwnership(newOwner);
              }
              /**
               * @dev Transfers ownership of the contract to a new account (`newOwner`).
               * Internal function without access restriction.
               */
              function _transferOwnership(address newOwner) internal virtual {
                  address oldOwner = _owner;
                  _owner = newOwner;
                  emit OwnershipTransferred(oldOwner, newOwner);
              }
              /**
               * @dev This empty reserved space is put in place to allow future versions to add new
               * variables without shifting down storage in the inheritance chain.
               * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
               */
              uint256[49] private __gap;
          }
          // SPDX-License-Identifier: MIT
          // OpenZeppelin Contracts (last updated v4.8.0) (proxy/utils/Initializable.sol)
          pragma solidity ^0.8.2;
          import "../../utils/AddressUpgradeable.sol";
          /**
           * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
           * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
           * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
           * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
           *
           * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
           * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
           * case an upgrade adds a module that needs to be initialized.
           *
           * For example:
           *
           * [.hljs-theme-light.nopadding]
           * ```
           * contract MyToken is ERC20Upgradeable {
           *     function initialize() initializer public {
           *         __ERC20_init("MyToken", "MTK");
           *     }
           * }
           * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
           *     function initializeV2() reinitializer(2) public {
           *         __ERC20Permit_init("MyToken");
           *     }
           * }
           * ```
           *
           * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
           * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
           *
           * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
           * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
           *
           * [CAUTION]
           * ====
           * Avoid leaving a contract uninitialized.
           *
           * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
           * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
           * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
           *
           * [.hljs-theme-light.nopadding]
           * ```
           * /// @custom:oz-upgrades-unsafe-allow constructor
           * constructor() {
           *     _disableInitializers();
           * }
           * ```
           * ====
           */
          abstract contract Initializable {
              /**
               * @dev Indicates that the contract has been initialized.
               * @custom:oz-retyped-from bool
               */
              uint8 private _initialized;
              /**
               * @dev Indicates that the contract is in the process of being initialized.
               */
              bool private _initializing;
              /**
               * @dev Triggered when the contract has been initialized or reinitialized.
               */
              event Initialized(uint8 version);
              /**
               * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
               * `onlyInitializing` functions can be used to initialize parent contracts.
               *
               * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a
               * constructor.
               *
               * Emits an {Initialized} event.
               */
              modifier initializer() {
                  bool isTopLevelCall = !_initializing;
                  require(
                      (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
                      "Initializable: contract is already initialized"
                  );
                  _initialized = 1;
                  if (isTopLevelCall) {
                      _initializing = true;
                  }
                  _;
                  if (isTopLevelCall) {
                      _initializing = false;
                      emit Initialized(1);
                  }
              }
              /**
               * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
               * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
               * used to initialize parent contracts.
               *
               * A reinitializer may be used after the original initialization step. This is essential to configure modules that
               * are added through upgrades and that require initialization.
               *
               * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
               * cannot be nested. If one is invoked in the context of another, execution will revert.
               *
               * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
               * a contract, executing them in the right order is up to the developer or operator.
               *
               * WARNING: setting the version to 255 will prevent any future reinitialization.
               *
               * Emits an {Initialized} event.
               */
              modifier reinitializer(uint8 version) {
                  require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
                  _initialized = version;
                  _initializing = true;
                  _;
                  _initializing = false;
                  emit Initialized(version);
              }
              /**
               * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
               * {initializer} and {reinitializer} modifiers, directly or indirectly.
               */
              modifier onlyInitializing() {
                  require(_initializing, "Initializable: contract is not initializing");
                  _;
              }
              /**
               * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
               * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
               * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
               * through proxies.
               *
               * Emits an {Initialized} event the first time it is successfully executed.
               */
              function _disableInitializers() internal virtual {
                  require(!_initializing, "Initializable: contract is initializing");
                  if (_initialized < type(uint8).max) {
                      _initialized = type(uint8).max;
                      emit Initialized(type(uint8).max);
                  }
              }
              /**
               * @dev Internal function that returns the initialized version. Returns `_initialized`
               */
              function _getInitializedVersion() internal view returns (uint8) {
                  return _initialized;
              }
              /**
               * @dev Internal function that returns the initialized version. Returns `_initializing`
               */
              function _isInitializing() internal view returns (bool) {
                  return _initializing;
              }
          }
          // SPDX-License-Identifier: MIT
          // OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)
          pragma solidity ^0.8.1;
          /**
           * @dev Collection of functions related to the address type
           */
          library AddressUpgradeable {
              /**
               * @dev Returns true if `account` is a contract.
               *
               * [IMPORTANT]
               * ====
               * It is unsafe to assume that an address for which this function returns
               * false is an externally-owned account (EOA) and not a contract.
               *
               * Among others, `isContract` will return false for the following
               * types of addresses:
               *
               *  - an externally-owned account
               *  - a contract in construction
               *  - an address where a contract will be created
               *  - an address where a contract lived, but was destroyed
               * ====
               *
               * [IMPORTANT]
               * ====
               * You shouldn't rely on `isContract` to protect against flash loan attacks!
               *
               * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
               * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
               * constructor.
               * ====
               */
              function isContract(address account) internal view returns (bool) {
                  // This method relies on extcodesize/address.code.length, which returns 0
                  // for contracts in construction, since the code is only stored at the end
                  // of the constructor execution.
                  return account.code.length > 0;
              }
              /**
               * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
               * `recipient`, forwarding all available gas and reverting on errors.
               *
               * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
               * of certain opcodes, possibly making contracts go over the 2300 gas limit
               * imposed by `transfer`, making them unable to receive funds via
               * `transfer`. {sendValue} removes this limitation.
               *
               * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
               *
               * IMPORTANT: because control is transferred to `recipient`, care must be
               * taken to not create reentrancy vulnerabilities. Consider using
               * {ReentrancyGuard} or the
               * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
               */
              function sendValue(address payable recipient, uint256 amount) internal {
                  require(address(this).balance >= amount, "Address: insufficient balance");
                  (bool success, ) = recipient.call{value: amount}("");
                  require(success, "Address: unable to send value, recipient may have reverted");
              }
              /**
               * @dev Performs a Solidity function call using a low level `call`. A
               * plain `call` is an unsafe replacement for a function call: use this
               * function instead.
               *
               * If `target` reverts with a revert reason, it is bubbled up by this
               * function (like regular Solidity function calls).
               *
               * Returns the raw returned data. To convert to the expected return value,
               * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
               *
               * Requirements:
               *
               * - `target` must be a contract.
               * - calling `target` with `data` must not revert.
               *
               * _Available since v3.1._
               */
              function functionCall(address target, bytes memory data) internal returns (bytes memory) {
                  return functionCallWithValue(target, data, 0, "Address: low-level call failed");
              }
              /**
               * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
               * `errorMessage` as a fallback revert reason when `target` reverts.
               *
               * _Available since v3.1._
               */
              function functionCall(
                  address target,
                  bytes memory data,
                  string memory errorMessage
              ) internal returns (bytes memory) {
                  return functionCallWithValue(target, data, 0, errorMessage);
              }
              /**
               * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
               * but also transferring `value` wei to `target`.
               *
               * Requirements:
               *
               * - the calling contract must have an ETH balance of at least `value`.
               * - the called Solidity function must be `payable`.
               *
               * _Available since v3.1._
               */
              function functionCallWithValue(
                  address target,
                  bytes memory data,
                  uint256 value
              ) internal returns (bytes memory) {
                  return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
              }
              /**
               * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
               * with `errorMessage` as a fallback revert reason when `target` reverts.
               *
               * _Available since v3.1._
               */
              function functionCallWithValue(
                  address target,
                  bytes memory data,
                  uint256 value,
                  string memory errorMessage
              ) internal returns (bytes memory) {
                  require(address(this).balance >= value, "Address: insufficient balance for call");
                  (bool success, bytes memory returndata) = target.call{value: value}(data);
                  return verifyCallResultFromTarget(target, success, returndata, errorMessage);
              }
              /**
               * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
               * but performing a static call.
               *
               * _Available since v3.3._
               */
              function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
                  return functionStaticCall(target, data, "Address: low-level static call failed");
              }
              /**
               * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
               * but performing a static call.
               *
               * _Available since v3.3._
               */
              function functionStaticCall(
                  address target,
                  bytes memory data,
                  string memory errorMessage
              ) internal view returns (bytes memory) {
                  (bool success, bytes memory returndata) = target.staticcall(data);
                  return verifyCallResultFromTarget(target, success, returndata, errorMessage);
              }
              /**
               * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
               * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
               *
               * _Available since v4.8._
               */
              function verifyCallResultFromTarget(
                  address target,
                  bool success,
                  bytes memory returndata,
                  string memory errorMessage
              ) internal view returns (bytes memory) {
                  if (success) {
                      if (returndata.length == 0) {
                          // only check isContract if the call was successful and the return data is empty
                          // otherwise we already know that it was a contract
                          require(isContract(target), "Address: call to non-contract");
                      }
                      return returndata;
                  } else {
                      _revert(returndata, errorMessage);
                  }
              }
              /**
               * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
               * revert reason or using the provided one.
               *
               * _Available since v4.3._
               */
              function verifyCallResult(
                  bool success,
                  bytes memory returndata,
                  string memory errorMessage
              ) internal pure returns (bytes memory) {
                  if (success) {
                      return returndata;
                  } else {
                      _revert(returndata, errorMessage);
                  }
              }
              function _revert(bytes memory returndata, string memory errorMessage) private pure {
                  // Look for revert reason and bubble it up if present
                  if (returndata.length > 0) {
                      // The easiest way to bubble the revert reason is using memory via assembly
                      /// @solidity memory-safe-assembly
                      assembly {
                          let returndata_size := mload(returndata)
                          revert(add(32, returndata), returndata_size)
                      }
                  } else {
                      revert(errorMessage);
                  }
              }
          }
          // SPDX-License-Identifier: MIT
          // OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
          pragma solidity ^0.8.0;
          import "../proxy/utils/Initializable.sol";
          /**
           * @dev Provides information about the current execution context, including the
           * sender of the transaction and its data. While these are generally available
           * via msg.sender and msg.data, they should not be accessed in such a direct
           * manner, since when dealing with meta-transactions the account sending and
           * paying for execution may not be the actual sender (as far as an application
           * is concerned).
           *
           * This contract is only required for intermediate, library-like contracts.
           */
          abstract contract ContextUpgradeable is Initializable {
              function __Context_init() internal onlyInitializing {
              }
              function __Context_init_unchained() internal onlyInitializing {
              }
              function _msgSender() internal view virtual returns (address) {
                  return msg.sender;
              }
              function _msgData() internal view virtual returns (bytes calldata) {
                  return msg.data;
              }
              /**
               * @dev This empty reserved space is put in place to allow future versions to add new
               * variables without shifting down storage in the inheritance chain.
               * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
               */
              uint256[50] private __gap;
          }
          // SPDX-License-Identifier: MIT
          // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol)
          pragma solidity ^0.8.0;
          import "../../utils/introspection/IERC165.sol";
          /**
           * @dev Required interface of an ERC721 compliant contract.
           */
          interface IERC721 is IERC165 {
              /**
               * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
               */
              event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
              /**
               * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
               */
              event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
              /**
               * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
               */
              event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
              /**
               * @dev Returns the number of tokens in ``owner``'s account.
               */
              function balanceOf(address owner) external view returns (uint256 balance);
              /**
               * @dev Returns the owner of the `tokenId` token.
               *
               * Requirements:
               *
               * - `tokenId` must exist.
               */
              function ownerOf(uint256 tokenId) external view returns (address owner);
              /**
               * @dev Safely transfers `tokenId` token from `from` to `to`.
               *
               * Requirements:
               *
               * - `from` cannot be the zero address.
               * - `to` cannot be the zero address.
               * - `tokenId` token must exist and be owned by `from`.
               * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
               * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
               *
               * Emits a {Transfer} event.
               */
              function safeTransferFrom(
                  address from,
                  address to,
                  uint256 tokenId,
                  bytes calldata data
              ) external;
              /**
               * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
               * are aware of the ERC721 protocol to prevent tokens from being forever locked.
               *
               * Requirements:
               *
               * - `from` cannot be the zero address.
               * - `to` cannot be the zero address.
               * - `tokenId` token must exist and be owned by `from`.
               * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.
               * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
               *
               * Emits a {Transfer} event.
               */
              function safeTransferFrom(
                  address from,
                  address to,
                  uint256 tokenId
              ) external;
              /**
               * @dev Transfers `tokenId` token from `from` to `to`.
               *
               * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
               * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
               * understand this adds an external call which potentially creates a reentrancy vulnerability.
               *
               * Requirements:
               *
               * - `from` cannot be the zero address.
               * - `to` cannot be the zero address.
               * - `tokenId` token must be owned by `from`.
               * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
               *
               * Emits a {Transfer} event.
               */
              function transferFrom(
                  address from,
                  address to,
                  uint256 tokenId
              ) external;
              /**
               * @dev Gives permission to `to` to transfer `tokenId` token to another account.
               * The approval is cleared when the token is transferred.
               *
               * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
               *
               * Requirements:
               *
               * - The caller must own the token or be an approved operator.
               * - `tokenId` must exist.
               *
               * Emits an {Approval} event.
               */
              function approve(address to, uint256 tokenId) external;
              /**
               * @dev Approve or remove `operator` as an operator for the caller.
               * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
               *
               * Requirements:
               *
               * - The `operator` cannot be the caller.
               *
               * Emits an {ApprovalForAll} event.
               */
              function setApprovalForAll(address operator, bool _approved) external;
              /**
               * @dev Returns the account approved for `tokenId` token.
               *
               * Requirements:
               *
               * - `tokenId` must exist.
               */
              function getApproved(uint256 tokenId) external view returns (address operator);
              /**
               * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
               *
               * See {setApprovalForAll}
               */
              function isApprovedForAll(address owner, address operator) external view returns (bool);
          }
          // SPDX-License-Identifier: MIT
          // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
          pragma solidity ^0.8.0;
          /**
           * @dev Interface of the ERC165 standard, as defined in the
           * https://eips.ethereum.org/EIPS/eip-165[EIP].
           *
           * Implementers can declare support of contract interfaces, which can then be
           * queried by others ({ERC165Checker}).
           *
           * For an implementation, see {ERC165}.
           */
          interface IERC165 {
              /**
               * @dev Returns true if this contract implements the interface defined by
               * `interfaceId`. See the corresponding
               * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
               * to learn more about how these ids are created.
               *
               * This function call must use less than 30 000 gas.
               */
              function supportsInterface(bytes4 interfaceId) external view returns (bool);
          }
          // SPDX-License-Identifier: MIT
          /*
                                              $MEMELAND
                                             kevinLAND$$$
                                          mVp           meme
                                         meME      BRIAN6 9$
                                        $sa|ya$   ISdicKbuTT
                                        !mVP$! $ca pta  inM$
                                        !j$oe$y!! TREASUREM$
                                         !MV $P!$         M$
                                         M$zpotatozmvp    M$           Cumm
                                         A$C$$staking$    M$          CHRIS
                                         R$H       MVP $d ontLAND   mvpR m$
                                         C$U       $$$ 69 T$rustverify IMvP
                                         O$N      9gag ceo   captain  aS$o
                                         !9GA     pOTATOZ$       RAY$9999$
                                           G!     !!$DICK$!         dyno
                                           poTa    BUTTZ!           m$
                                             to                   9gag
                                              LETSFUCKING!  GROW!!!
                                              RAY$    ISMVP ME
                                             DERE K!   lanD me
                                           kArEnc IS j6r9an LA
                                           tReASURE$ meMelandnD
          */
          pragma solidity ^0.8.16;
          import "./Guardian/Erc721LockRegistry.sol";
          import "./OPR/upgradeable/DefaultOperatorFiltererUpgradeable.sol";
          import "./interfaces/IPotatoz.sol";
          import "./interfaces/ICaptainz.sol";
          import "./interfaces/IMVP.sol";
          contract Captainz is ERC721x, DefaultOperatorFiltererUpgradeable, ICaptainz {
              string public baseTokenURI;
              string public tokenURISuffix;
              string public tokenURIOverride;
              uint256 public MAX_SUPPLY;
              event QuestStarted(uint256 indexed tokenId, uint256 questStartedAt, uint256[] crews);
              event QuestEdited(uint256 indexed tokenId, uint256 questStartedAt, uint256[] crews, uint256 questEditedAt);
              event QuestStopped(
                  uint256 indexed tokenId,
                  uint256 questStartedAt,
                  uint256 questStoppedAt
              );
              event ChestRevealed(uint256 indexed tokenId);
              IPotatoz public potatozContract;
              uint256 public MAX_CREWS;
              bool public canQuest;
              mapping(uint256 => uint256) public tokensLastQuestedAt; // captainz tokenId => timestamp
              mapping(uint256 => uint256[]) public questCrews; // captainz tokenId => potatoz tokenIds
              mapping(uint256 => uint256[]) public potatozCrew; // potatoz tokenId => captainz tokenId [array of 1 uint256]
              mapping(uint256 => bool) public revealed; // captains tokenId => revealed
              IMVP public mvpContract;
              // =============== V3 ===============
              mapping(address => bool) public moderators;
              /// @custom:oz-upgrades-unsafe-allow constructor
              constructor() {
                  _disableInitializers();
              }
              function initialize(string memory baseURI) public initializer {
                  DefaultOperatorFiltererUpgradeable.__DefaultOperatorFilterer_init();
                  ERC721x.__ERC721x_init("Captainz", "Captainz");
                  baseTokenURI = baseURI;
                  MAX_SUPPLY = 9999;
              }
              function initializeV2() public onlyOwner reinitializer(2) {
                  MAX_CREWS = 3;
              }
              function safeMint(address receiver, uint256 quantity) internal {
                  require(_totalMinted() + quantity <= MAX_SUPPLY, "exceed MAX_SUPPLY");
                  _mint(receiver, quantity);
              }
              // =============== Airdrop ===============
              function airdropWithAmounts(
                  address[] memory receivers,
                  uint256[] memory amounts
              ) external onlyOwner {
                  require(receivers.length >= 1, "at least 1 receiver");
                  for (uint256 i; i < receivers.length; i++) {
                      address receiver = receivers[i];
                      safeMint(receiver, amounts[i]);
                  }
              }
              // =============== URI ===============
              function compareStrings(string memory a, string memory b)
                  public
                  pure
                  returns (bool)
              {
                  return keccak256(abi.encodePacked(a)) == keccak256(abi.encodePacked(b));
              }
              function _baseURI() internal view virtual override returns (string memory) {
                  return baseTokenURI;
              }
              function tokenURI(uint256 _tokenId)
                  public
                  view
                  override(ERC721AUpgradeable, IERC721AUpgradeable)
                  returns (string memory)
              {
                  if (bytes(tokenURIOverride).length > 0) {
                      return tokenURIOverride;
                  }
                  return string.concat(super.tokenURI(_tokenId), tokenURISuffix);
              }
              function setBaseURI(string calldata baseURI) external onlyOwner {
                  baseTokenURI = baseURI;
              }
              function setTokenURISuffix(string calldata _tokenURISuffix)
                  external
                  onlyOwner
              {
                  if (compareStrings(_tokenURISuffix, "!empty!")) {
                      tokenURISuffix = "";
                  } else {
                      tokenURISuffix = _tokenURISuffix;
                  }
              }
              function setTokenURIOverride(string calldata _tokenURIOverride)
                  external
                  onlyOwner
              {
                  if (compareStrings(_tokenURIOverride, "!empty!")) {
                      tokenURIOverride = "";
                  } else {
                      tokenURIOverride = _tokenURIOverride;
                  }
              }
              // =============== Stake + MARKETPLACE CONTROL ===============
              function transferFrom(
                  address from,
                  address to,
                  uint256 tokenId
              ) public override(ERC721x) onlyAllowedOperator(from) {
                  require(
                      tokensLastQuestedAt[tokenId] == 0,
                      "Cannot transfer questing token"
                  );
                  super.transferFrom(from, to, tokenId);
              }
              function safeTransferFrom(
                  address from,
                  address to,
                  uint256 tokenId,
                  bytes memory _data
              ) public override(ERC721x) onlyAllowedOperator(from) {
                  require(
                      tokensLastQuestedAt[tokenId] == 0,
                      "Cannot transfer questing token"
                  );
                  super.safeTransferFrom(from, to, tokenId, _data);
              }
              // =============== Questing ===============
              struct QuestInfo {
                  uint256 tokenId;
                  uint256[] potatozTokenIds;
              }
              function batchStartQuest(QuestInfo[] calldata questInfos) external {
                  uint256 batch = questInfos.length;
                  for (uint256 i; i < batch;) {
                      startQuest(questInfos[i].tokenId, questInfos[i].potatozTokenIds);
                      unchecked { ++i; }
                  }
              }
              function batchEditQuest(QuestInfo[] calldata questInfos) external {
                  require(canQuest, "questing not open");
                  require(address(potatozContract) != address(0), "potatozContract not set");
                  uint256 batch = questInfos.length;
                  for (uint256 i; i < batch;) {
                      uint256 tokenId = questInfos[i].tokenId;
                      require(msg.sender == ownerOf(tokenId), "not owner of [captainz tokenId]");
                      require(tokensLastQuestedAt[tokenId] > 0, "quested not started for [captainz tokenId]");
                      _resetCrew(tokenId);
                      unchecked { ++i; }
                  }
                  for (uint256 i; i < batch;) {
                      uint256 tokenId = questInfos[i].tokenId;
                      uint256[] calldata potatozTokenIds = questInfos[i].potatozTokenIds;
                      require(potatozTokenIds.length <= MAX_CREWS, "too many crews [potatozTokenIds]");
                      _addCrew(tokenId, potatozTokenIds);
                      emit QuestEdited(tokenId, tokensLastQuestedAt[tokenId], potatozTokenIds, block.timestamp);
                      unchecked { ++i; }
                  }
              }
              function batchStopQuest(uint256[] calldata tokenIds) external {
                  uint256 batch = tokenIds.length;
                  for (uint256 i; i < batch;) {
                      stopQuest(tokenIds[i]);
                      unchecked { ++i; }
                  }
              }
              function startQuest(uint256 tokenId, uint256[] calldata potatozTokenIds) public {
                  require(canQuest, "questing not open");
                  require(address(potatozContract) != address(0), "potatozContract not set");
                  require(msg.sender == ownerOf(tokenId), "not owner of [captainz tokenId]");
                  require(tokensLastQuestedAt[tokenId] == 0, "quested already started for [captainz tokenId]");
                  require(potatozTokenIds.length <= MAX_CREWS, "too many crews [potatozTokenIds]");
                  _addCrew(tokenId, potatozTokenIds);
                  tokensLastQuestedAt[tokenId] = block.timestamp;
                  emit QuestStarted(tokenId, block.timestamp, potatozTokenIds);
                  if (!revealed[tokenId]) {
                      revealed[tokenId] = true;
                      emit ChestRevealed(tokenId);
                  }
              }
              function editQuest(uint256 tokenId, uint256[] calldata potatozTokenIds) public {
                  require(canQuest, "questing not open");
                  require(address(potatozContract) != address(0), "potatozContract not set");
                  require(msg.sender == ownerOf(tokenId), "not owner of [captainz tokenId]");
                  require(tokensLastQuestedAt[tokenId] > 0, "quested not started for [captainz tokenId]");
                  require(potatozTokenIds.length <= MAX_CREWS, "too many crews [potatozTokenIds]");
                  _resetCrew(tokenId);
                  _addCrew(tokenId, potatozTokenIds);
                  emit QuestEdited(tokenId, tokensLastQuestedAt[tokenId], potatozTokenIds, block.timestamp);
              }
              function _addCrew(uint256 tokenId, uint256[] calldata potatozTokenIds) private {
                  uint256 crews = potatozTokenIds.length;
                  if (crews >= 1) {
                      uint256[] memory wrapper = new uint256[](1);
                      wrapper[0] = tokenId;
                      for (uint256 i; i < crews;) {
                          uint256 pTokenId = potatozTokenIds[i];
                          require(potatozContract.nftOwnerOf(pTokenId) == msg.sender, "not owner of [potatoz tokenId]");
                          if (!potatozContract.isPotatozStaking(pTokenId)) {
                              potatozContract.stakeExternal(pTokenId);
                          }
                          uint256[] storage existCheck = potatozCrew[pTokenId];
                          if (existCheck.length != 0) {
                              removeCrew(pTokenId);
                          }
                          potatozCrew[pTokenId] = wrapper;
                          unchecked { ++i; }
                      }
                      questCrews[tokenId] = potatozTokenIds;
                  }
              }
              function removeCrew(uint256 potatozTokenId) public {
                  require(address(potatozContract) != address(0), "potatozContract not set");
                  require(
                      msg.sender == potatozContract.nftOwnerOf(potatozTokenId) || msg.sender == address(potatozContract),
                      "caller must be any: potatoz owner, potatoz"
                  );
                  uint256[] storage existCheck = potatozCrew[potatozTokenId];
                  require(existCheck.length != 0, "potatozTokenId not questing");
                  uint256 tokenId = existCheck[0];
                  uint256 empty = MAX_SUPPLY;
                  uint256[] memory pTokenIds = questCrews[tokenId];
                  uint256 crews = pTokenIds.length;
                  uint256 crewLength = pTokenIds.length;
                  for (uint256 i; i < crews;) {
                      uint256 pTokenId = pTokenIds[i];
                      if (pTokenId == potatozTokenId) {
                          pTokenIds[i] = empty;
                          crewLength--;
                      }
                      unchecked { ++i; }
                  }
                  require(pTokenIds.length != crewLength, "potatozTokenId not in crew");
                  uint256[] memory newCrews = new uint256[](crewLength);
                  uint256 activeIdx;
                  for (uint256 i; i < crews;) {
                      if (pTokenIds[i] != empty) {
                          newCrews[activeIdx++] = pTokenIds[i];
                      }
                      unchecked { ++i; }
                  }
                  questCrews[tokenId] = newCrews;
                  potatozCrew[potatozTokenId] = new uint256[](0);
              }
              function _resetCrew(uint256 tokenId) private {
                  uint256[] storage potatozTokenIds = questCrews[tokenId];
                  uint256 crews = potatozTokenIds.length;
                  if (crews >= 1) {
                      uint256[] memory empty = new uint256[](0);
                      for (uint256 i; i < crews;) {
                          uint256 pTokenId = potatozTokenIds[i];
                          potatozCrew[pTokenId] = empty;
                          unchecked { ++i; }
                      }
                      questCrews[tokenId] = empty;
                  }
              }
              function stopQuest(uint256 tokenId) public {
                  require(
                      msg.sender == ownerOf(tokenId) || msg.sender == owner() || moderators[msg.sender],
                      "not owner of [captainz tokenId]"
                  );
                  require(tokensLastQuestedAt[tokenId] > 0, "quested not started for [captainz tokenId]");
                  if (address(mvpContract) != address(0) && mvpContract.isCaptainzBoosting(tokenId)) {
                      mvpContract.removeCaptainz(tokenId);
                  }
                  _resetCrew(tokenId);
                  uint256 tlqa = tokensLastQuestedAt[tokenId];
                  tokensLastQuestedAt[tokenId] = 0;
                  emit QuestStopped(tokenId, tlqa, block.timestamp);
              }
              function isPotatozQuesting(uint256 tokenId) external view returns (bool) {
                  uint256[] storage existCheck = potatozCrew[tokenId];
                  return existCheck.length > 0;
              }
              function getTokenInfo(uint256 tokenId) external view returns (uint256 lastQuestedAt, uint256[] memory crewTokenIds, bool hasRevealed) {
                  return (tokensLastQuestedAt[tokenId], questCrews[tokenId], revealed[tokenId]);
              }
              function getActiveCrews(uint256 tokenId) external view returns (uint256[] memory) {
                  require(address(potatozContract) != address(0), "potatozContract not set");
                  address owner = ownerOf(tokenId);
                  uint256[] memory pTokenIds = questCrews[tokenId];
                  uint256 crews = pTokenIds.length;
                  uint256 activeLength = pTokenIds.length;
                  uint256 empty = MAX_SUPPLY;
                  for (uint256 i; i < crews;) {
                      uint256 pTokenId = pTokenIds[i];
                      if (potatozContract.nftOwnerOf(pTokenId) != owner || !potatozContract.isPotatozStaking(pTokenId)) {
                          pTokenIds[i] = empty;
                          activeLength--;
                      }
                      unchecked { ++i; }
                  }
                  uint256[] memory activeCrews = new uint256[](activeLength);
                  uint256 activeIdx;
                  for (uint256 i; i < crews;) {
                      if (pTokenIds[i] != empty) {
                          activeCrews[activeIdx++] = pTokenIds[i];
                      }
                      unchecked { ++i; }
                  }
                  return activeCrews;
              }
              // =============== Admin ===============
              function setCanQuest(bool b) external onlyOwner {
                  canQuest = b;
              }
              function setPotatozContract(address addr) external onlyOwner {
                  potatozContract = IPotatoz(addr);
              }
              function setMvpContract(address addr) external onlyOwner {
                  mvpContract = IMVP(addr);
              }
              function setModerator(address addr, bool add) external onlyOwner {
                  moderators[addr] = add;
              }
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.14;
          import "erc721a-upgradeable/contracts/extensions/ERC721AQueryableUpgradeable.sol";
          contract ERC721ANamable is ERC721AQueryableUpgradeable {
              mapping(uint256 => string) public bio;
              // Mapping from token ID to name
              mapping(uint256 => string) private _tokenName;
              // Mapping if certain name string has already been reserved
              mapping(string => bool) private _nameReserved;
              event NameChange(uint256 indexed tokenId, string newName);
              event BioChange(uint256 indexed tokenId, string bio);
              function __ERC721ANamable_init(string memory _name, string memory _symbol)
                  internal
                  initializerERC721A
              {
                  ERC721AUpgradeable.__ERC721A_init(_name, _symbol);
              }
              function changeBio(uint256 _tokenId, string memory _bio) public virtual {
                  address owner = ownerOf(_tokenId);
                  require(msg.sender == owner, "ERC721: caller is not the owner");
                  bio[_tokenId] = _bio;
                  emit BioChange(_tokenId, _bio);
              }
              function changeName(uint256 tokenId, string memory newName) public virtual {
                  address owner = ownerOf(tokenId);
                  require(msg.sender == owner, "ERC721: caller is not the owner");
                  require(validateName(newName) == true, "Not a valid new name");
                  require(
                      sha256(bytes(newName)) != sha256(bytes(_tokenName[tokenId])),
                      "New name is same as the current one"
                  );
                  require(isNameReserved(newName) == false, "Name already reserved");
                  // If already named, dereserve old name
                  if (bytes(_tokenName[tokenId]).length > 0) {
                      toggleReserveName(_tokenName[tokenId], false);
                  }
                  toggleReserveName(newName, true);
                  _tokenName[tokenId] = newName;
                  emit NameChange(tokenId, newName);
              }
              /**
               * @dev Reserves the name if isReserve is set to true, de-reserves if set to false
               */
              function toggleReserveName(string memory str, bool isReserve) internal {
                  _nameReserved[toLower(str)] = isReserve;
              }
              /**
               * @dev Returns name of the NFT at index.
               */
              function tokenNameByIndex(uint256 index)
                  public
                  view
                  returns (string memory)
              {
                  return _tokenName[index];
              }
              /**
               * @dev Returns if the name has been reserved.
               */
              function isNameReserved(string memory nameString)
                  public
                  view
                  returns (bool)
              {
                  return _nameReserved[toLower(nameString)];
              }
              function validateName(string memory str) public pure returns (bool) {
                  bytes memory b = bytes(str);
                  if (b.length < 1) return false;
                  if (b.length > 25) return false; // Cannot be longer than 25 characters
                  if (b[0] == 0x20) return false; // Leading space
                  if (b[b.length - 1] == 0x20) return false; // Trailing space
                  bytes1 lastChar = b[0];
                  for (uint256 i; i < b.length; i++) {
                      bytes1 char = b[i];
                      if (char == 0x20 && lastChar == 0x20) return false; // Cannot contain continous spaces
                      if (
                          !(char >= 0x30 && char <= 0x39) && //9-0
                          !(char >= 0x41 && char <= 0x5A) && //A-Z
                          !(char >= 0x61 && char <= 0x7A) && //a-z
                          !(char == 0x20) //space
                      ) return false;
                      lastChar = char;
                  }
                  return true;
              }
              /**
               * @dev Converts the string to lowercase
               */
              function toLower(string memory str) public pure returns (string memory) {
                  bytes memory bStr = bytes(str);
                  bytes memory bLower = new bytes(bStr.length);
                  for (uint256 i = 0; i < bStr.length; i++) {
                      // Uppercase character
                      if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) {
                          bLower[i] = bytes1(uint8(bStr[i]) + 32);
                      } else {
                          bLower[i] = bStr[i];
                      }
                  }
                  return string(bLower);
              }
          }
          // SPDX-License-Identifier: UNLICENSED
          pragma solidity ^0.8.14;
          /*
           *     ,_,
           *    (',')
           *    {/"\\\\}
           *    -"-"-
           */
          import "./ERC721ANamable.sol";
          import "./LockRegistry.sol";
          import "./IERC721x.sol";
          contract ERC721x is ERC721ANamable, LockRegistry {
              /*
               *     bytes4(keccak256('freeId(uint256,address)')) == 0x94d216d6
               *     bytes4(keccak256('isUnlocked(uint256)')) == 0x72abc8b7
               *     bytes4(keccak256('lockCount(uint256)')) == 0x650b00f6
               *     bytes4(keccak256('lockId(uint256)')) == 0x2799cde0
               *     bytes4(keccak256('lockMap(uint256,uint256)')) == 0x2cba8123
               *     bytes4(keccak256('lockMapIndex(uint256,address)')) == 0x09308e5d
               *     bytes4(keccak256('unlockId(uint256)')) == 0x40a9c8df
               *     bytes4(keccak256('approvedContract(address)')) == 0xb1a6505f
               *
               *     => 0x94d216d6 ^ 0x72abc8b7 ^ 0x650b00f6 ^ 0x2799cde0 ^
               *        0x2cba8123 ^ 0x09308e5d ^ 0x40a9c8df ^ 0xb1a6505f == 0x706e8489
               */
              bytes4 private constant _INTERFACE_ID_ERC721x = 0x706e8489;
              function __ERC721x_init(string memory _name, string memory _symbol)
                  internal
                  onlyInitializing
              {
                  ERC721ANamable.__ERC721ANamable_init(_name, _symbol);
                  LockRegistry.__LockRegistry_init();
              }
              function supportsInterface(bytes4 _interfaceId)
                  public
                  view
                  virtual
                  override(ERC721AUpgradeable, IERC721AUpgradeable)
                  returns (bool)
              {
                  return
                      _interfaceId == _INTERFACE_ID_ERC721x ||
                      super.supportsInterface(_interfaceId);
              }
              function transferFrom(
                  address _from,
                  address _to,
                  uint256 _tokenId
              ) public virtual override(ERC721AUpgradeable, IERC721AUpgradeable) {
                  require(isUnlocked(_tokenId), "Token is locked");
                  ERC721AUpgradeable.transferFrom(_from, _to, _tokenId);
              }
              function safeTransferFrom(
                  address _from,
                  address _to,
                  uint256 _tokenId,
                  bytes memory _data
              ) public virtual override(ERC721AUpgradeable, IERC721AUpgradeable) {
                  require(isUnlocked(_tokenId), "Token is locked");
                  ERC721AUpgradeable.safeTransferFrom(
                      _from,
                      _to,
                      _tokenId,
                      _data
                  );
              }
              function lockId(uint256 _id) external virtual override {
                  require(_exists(_id), "Token !exist");
                  _lockId(_id);
              }
              function unlockId(uint256 _id) external virtual override {
                  require(_exists(_id), "Token !exist");
                  _unlockId(_id);
              }
              function freeId(uint256 _id, address _contract) external virtual override {
                  require(_exists(_id), "Token !exist");
                  _freeId(_id, _contract);
              }
          }
          // SPDX-License-Identifier: UNLICENSED
          pragma solidity ^0.8.14;
          interface IERC721x {
              /**
               * @dev Returns if the token is locked (non-transferrable) or not.
               */
              function isUnlocked(uint256 _id) external view returns (bool);
              /**
               * @dev Returns the amount of locks on the token.
               */
              function lockCount(uint256 _tokenId) external view returns (uint256);
              /**
               * @dev Returns if a contract is allowed to lock/unlock tokens.
               */
              function approvedContract(address _contract) external view returns (bool);
              /**
               * @dev Returns the contract that locked a token at a specific index in the mapping.
               */
              function lockMap(uint256 _tokenId, uint256 _index)
                  external
                  view
                  returns (address);
              /**
               * @dev Returns the mapping index of a contract that locked a token.
               */
              function lockMapIndex(uint256 _tokenId, address _contract)
                  external
                  view
                  returns (uint256);
              /**
               * @dev Locks a token, preventing it from being transferrable
               */
              function lockId(uint256 _id) external;
              /**
               * @dev Unlocks a token.
               */
              function unlockId(uint256 _id) external;
              /**
               * @dev Unlocks a token from a given contract if the contract is no longer approved.
               */
              function freeId(uint256 _id, address _contract) external;
          }
          // SPDX-License-Identifier: UNLICENSED
          pragma solidity ^0.8.14;
          /*
           *     ,_,
           *    (',')
           *    {/"\\\\}
           *    -"-"-
           */
          import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
          // import "@openzeppelin/contracts/access/Ownable.sol";
          import "./IERC721x.sol";
          abstract contract LockRegistry is OwnableUpgradeable, IERC721x {
              mapping(address => bool) public override approvedContract;
              mapping(uint256 => uint256) public override lockCount;
              mapping(uint256 => mapping(uint256 => address)) public override lockMap;
              mapping(uint256 => mapping(address => uint256))
                  public
                  override lockMapIndex;
              event TokenLocked(
                  uint256 indexed tokenId,
                  address indexed approvedContract
              );
              event TokenUnlocked(
                  uint256 indexed tokenId,
                  address indexed approvedContract
              );
              function __LockRegistry_init() internal onlyInitializing {
                  OwnableUpgradeable.__Ownable_init();
              }
              function isUnlocked(uint256 _id) public view override returns (bool) {
                  return lockCount[_id] == 0;
              }
              function updateApprovedContracts(
                  address[] calldata _contracts,
                  bool[] calldata _values
              ) external onlyOwner {
                  require(_contracts.length == _values.length, "!length");
                  for (uint256 i = 0; i < _contracts.length; i++)
                      approvedContract[_contracts[i]] = _values[i];
              }
              function _lockId(uint256 _id) internal {
                  require(approvedContract[msg.sender], "Cannot update map");
                  require(
                      lockMapIndex[_id][msg.sender] == 0,
                      "ID already locked by caller"
                  );
                  uint256 count = lockCount[_id] + 1;
                  lockMap[_id][count] = msg.sender;
                  lockMapIndex[_id][msg.sender] = count;
                  lockCount[_id]++;
                  emit TokenLocked(_id, msg.sender);
              }
              function _unlockId(uint256 _id) internal {
                  require(approvedContract[msg.sender], "Cannot update map");
                  uint256 index = lockMapIndex[_id][msg.sender];
                  require(index != 0, "ID not locked by caller");
                  uint256 last = lockCount[_id];
                  if (index != last) {
                      address lastContract = lockMap[_id][last];
                      lockMap[_id][index] = lastContract;
                      lockMap[_id][last] = address(0);
                      lockMapIndex[_id][lastContract] = index;
                  } else lockMap[_id][index] = address(0);
                  lockMapIndex[_id][msg.sender] = 0;
                  lockCount[_id]--;
                  emit TokenUnlocked(_id, msg.sender);
              }
              function _freeId(uint256 _id, address _contract) internal {
                  require(!approvedContract[_contract], "Cannot update map");
                  uint256 index = lockMapIndex[_id][_contract];
                  require(index != 0, "ID not locked");
                  uint256 last = lockCount[_id];
                  if (index != last) {
                      address lastContract = lockMap[_id][last];
                      lockMap[_id][index] = lastContract;
                      lockMap[_id][last] = address(0);
                      lockMapIndex[_id][lastContract] = index;
                  } else lockMap[_id][index] = address(0);
                  lockMapIndex[_id][_contract] = 0;
                  lockCount[_id]--;
                  emit TokenUnlocked(_id, _contract);
              }
          }
          // SPDX-License-Identifier: UNLICENSED
          pragma solidity ^0.8.16;
          import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
          interface ICaptainz {
              function isPotatozQuesting(uint256 tokenId) external view returns (bool);
              function removeCrew(uint256 potatozTokenId) external;
          }// SPDX-License-Identifier: UNLICENSED
          pragma solidity ^0.8.16;
          import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
          interface IMVP {
              function isCaptainzBoosting(uint256 tokenId) external view returns (bool);
              function removeCaptainz(uint256 captainzTokenId) external;
          }
          // SPDX-License-Identifier: UNLICENSED
          pragma solidity ^0.8.16;
          import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
          interface IPotatoz {
              function isPotatozStaking(uint256 tokenId) external view returns (bool);
              function stakeExternal(uint256 tokenId) external;
              function nftOwnerOf(uint256 tokenId) external view returns (address);
          }// SPDX-License-Identifier: MIT
          pragma solidity ^0.8.13;
          interface IOperatorFilterRegistry {
              function isOperatorAllowed(address registrant, address operator) external view returns (bool);
              function register(address registrant) external;
              function registerAndSubscribe(address registrant, address subscription) external;
              function registerAndCopyEntries(address registrant, address registrantToCopy) external;
              function updateOperator(address registrant, address operator, bool filtered) external;
              function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
              function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
              function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
              function subscribe(address registrant, address registrantToSubscribe) external;
              function unsubscribe(address registrant, bool copyExistingEntries) external;
              function subscriptionOf(address addr) external returns (address registrant);
              function subscribers(address registrant) external returns (address[] memory);
              function subscriberAt(address registrant, uint256 index) external returns (address);
              function copyEntriesOf(address registrant, address registrantToCopy) external;
              function isOperatorFiltered(address registrant, address operator) external returns (bool);
              function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
              function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
              function filteredOperators(address addr) external returns (address[] memory);
              function filteredCodeHashes(address addr) external returns (bytes32[] memory);
              function filteredOperatorAt(address registrant, uint256 index) external returns (address);
              function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
              function isRegistered(address addr) external returns (bool);
              function codeHashOf(address addr) external returns (bytes32);
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.13;
          import {OperatorFiltererUpgradeable} from "./OperatorFiltererUpgradeable.sol";
          abstract contract DefaultOperatorFiltererUpgradeable is OperatorFiltererUpgradeable {
              address constant DEFAULT_SUBSCRIPTION = address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);
              function __DefaultOperatorFilterer_init() public onlyInitializing {
                  OperatorFiltererUpgradeable.__OperatorFilterer_init(DEFAULT_SUBSCRIPTION, true);
              }
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.13;
          import {IOperatorFilterRegistry} from "../IOperatorFilterRegistry.sol";
          import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
          abstract contract OperatorFiltererUpgradeable is Initializable {
              error OperatorNotAllowed(address operator);
              IOperatorFilterRegistry constant operatorFilterRegistry =
                  IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);
              function __OperatorFilterer_init(address subscriptionOrRegistrantToCopy, bool subscribe) public onlyInitializing {
                  // If an inheriting token contract is deployed to a network without the registry deployed, the modifier
                  // will not revert, but the contract will need to be registered with the registry once it is deployed in
                  // order for the modifier to filter addresses.
                  if (address(operatorFilterRegistry).code.length > 0) {
                      if (!operatorFilterRegistry.isRegistered(address(this))) {
                          if (subscribe) {
                              operatorFilterRegistry.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy);
                          } else {
                              if (subscriptionOrRegistrantToCopy != address(0)) {
                                  operatorFilterRegistry.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy);
                              } else {
                                  operatorFilterRegistry.register(address(this));
                              }
                          }
                      }
                  }
              }
              modifier onlyAllowedOperator(address from) virtual {
                  // Check registry code length to facilitate testing in environments without a deployed registry.
                  if (address(operatorFilterRegistry).code.length > 0) {
                      // Allow spending tokens from addresses with balance
                      // Note that this still allows listings and marketplaces with escrow to transfer tokens if transferred
                      // from an EOA.
                      if (from == msg.sender) {
                          _;
                          return;
                      }
                      if (
                          !(
                              operatorFilterRegistry.isOperatorAllowed(address(this), msg.sender)
                                  && operatorFilterRegistry.isOperatorAllowed(address(this), from)
                          )
                      ) {
                          revert OperatorNotAllowed(msg.sender);
                      }
                  }
                  _;
              }
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.0;
          /**
           * @dev This is a base contract to aid in writing upgradeable diamond facet contracts, or any kind of contract that will be deployed
           * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
           * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
           * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
           *
           * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
           * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
           *
           * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
           * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
           */
          import {ERC721A__InitializableStorage} from './ERC721A__InitializableStorage.sol';
          abstract contract ERC721A__Initializable {
              using ERC721A__InitializableStorage for ERC721A__InitializableStorage.Layout;
              /**
               * @dev Modifier to protect an initializer function from being invoked twice.
               */
              modifier initializerERC721A() {
                  // If the contract is initializing we ignore whether _initialized is set in order to support multiple
                  // inheritance patterns, but we only do this in the context of a constructor, because in other contexts the
                  // contract may have been reentered.
                  require(
                      ERC721A__InitializableStorage.layout()._initializing
                          ? _isConstructor()
                          : !ERC721A__InitializableStorage.layout()._initialized,
                      'ERC721A__Initializable: contract is already initialized'
                  );
                  bool isTopLevelCall = !ERC721A__InitializableStorage.layout()._initializing;
                  if (isTopLevelCall) {
                      ERC721A__InitializableStorage.layout()._initializing = true;
                      ERC721A__InitializableStorage.layout()._initialized = true;
                  }
                  _;
                  if (isTopLevelCall) {
                      ERC721A__InitializableStorage.layout()._initializing = false;
                  }
              }
              /**
               * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
               * {initializer} modifier, directly or indirectly.
               */
              modifier onlyInitializingERC721A() {
                  require(
                      ERC721A__InitializableStorage.layout()._initializing,
                      'ERC721A__Initializable: contract is not initializing'
                  );
                  _;
              }
              /// @dev Returns true if and only if the function is running in the constructor
              function _isConstructor() private view returns (bool) {
                  // extcodesize checks the size of the code stored in an address, and
                  // address returns the current address. Since the code is still not
                  // deployed when running a constructor, any checks on its code size will
                  // yield zero, making it an effective way to detect if a contract is
                  // under construction or not.
                  address self = address(this);
                  uint256 cs;
                  assembly {
                      cs := extcodesize(self)
                  }
                  return cs == 0;
              }
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.0;
          /**
           * @dev This is a base storage for the  initialization function for upgradeable diamond facet contracts
           **/
          library ERC721A__InitializableStorage {
              struct Layout {
                  /*
                   * Indicates that the contract has been initialized.
                   */
                  bool _initialized;
                  /*
                   * Indicates that the contract is in the process of being initialized.
                   */
                  bool _initializing;
              }
              bytes32 internal constant STORAGE_SLOT = keccak256('ERC721A.contracts.storage.initializable.facet');
              function layout() internal pure returns (Layout storage l) {
                  bytes32 slot = STORAGE_SLOT;
                  assembly {
                      l.slot := slot
                  }
              }
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.0;
          library ERC721AStorage {
              // Reference type for token approval.
              struct TokenApprovalRef {
                  address value;
              }
              struct Layout {
                  // =============================================================
                  //                            STORAGE
                  // =============================================================
                  // The next token ID to be minted.
                  uint256 _currentIndex;
                  // The number of tokens burned.
                  uint256 _burnCounter;
                  // Token name
                  string _name;
                  // Token symbol
                  string _symbol;
                  // Mapping from token ID to ownership details
                  // An empty struct value does not necessarily mean the token is unowned.
                  // See {_packedOwnershipOf} implementation for details.
                  //
                  // Bits Layout:
                  // - [0..159]   `addr`
                  // - [160..223] `startTimestamp`
                  // - [224]      `burned`
                  // - [225]      `nextInitialized`
                  // - [232..255] `extraData`
                  mapping(uint256 => uint256) _packedOwnerships;
                  // Mapping owner address to address data.
                  //
                  // Bits Layout:
                  // - [0..63]    `balance`
                  // - [64..127]  `numberMinted`
                  // - [128..191] `numberBurned`
                  // - [192..255] `aux`
                  mapping(address => uint256) _packedAddressData;
                  // Mapping from token ID to approved address.
                  mapping(uint256 => ERC721AStorage.TokenApprovalRef) _tokenApprovals;
                  // Mapping from owner to operator approvals
                  mapping(address => mapping(address => bool)) _operatorApprovals;
              }
              bytes32 internal constant STORAGE_SLOT = keccak256('ERC721A.contracts.storage.ERC721A');
              function layout() internal pure returns (Layout storage l) {
                  bytes32 slot = STORAGE_SLOT;
                  assembly {
                      l.slot := slot
                  }
              }
          }
          // SPDX-License-Identifier: MIT
          // ERC721A Contracts v4.2.2
          // Creator: Chiru Labs
          pragma solidity ^0.8.4;
          import './IERC721AUpgradeable.sol';
          import {ERC721AStorage} from './ERC721AStorage.sol';
          import './ERC721A__Initializable.sol';
          /**
           * @dev Interface of ERC721 token receiver.
           */
          interface ERC721A__IERC721ReceiverUpgradeable {
              function onERC721Received(
                  address operator,
                  address from,
                  uint256 tokenId,
                  bytes calldata data
              ) external returns (bytes4);
          }
          /**
           * @title ERC721A
           *
           * @dev Implementation of the [ERC721](https://eips.ethereum.org/EIPS/eip-721)
           * Non-Fungible Token Standard, including the Metadata extension.
           * Optimized for lower gas during batch mints.
           *
           * Token IDs are minted in sequential order (e.g. 0, 1, 2, 3, ...)
           * starting from `_startTokenId()`.
           *
           * Assumptions:
           *
           * - An owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
           * - The maximum token ID cannot exceed 2**256 - 1 (max value of uint256).
           */
          contract ERC721AUpgradeable is ERC721A__Initializable, IERC721AUpgradeable {
              using ERC721AStorage for ERC721AStorage.Layout;
              // =============================================================
              //                           CONSTANTS
              // =============================================================
              // Mask of an entry in packed address data.
              uint256 private constant _BITMASK_ADDRESS_DATA_ENTRY = (1 << 64) - 1;
              // The bit position of `numberMinted` in packed address data.
              uint256 private constant _BITPOS_NUMBER_MINTED = 64;
              // The bit position of `numberBurned` in packed address data.
              uint256 private constant _BITPOS_NUMBER_BURNED = 128;
              // The bit position of `aux` in packed address data.
              uint256 private constant _BITPOS_AUX = 192;
              // Mask of all 256 bits in packed address data except the 64 bits for `aux`.
              uint256 private constant _BITMASK_AUX_COMPLEMENT = (1 << 192) - 1;
              // The bit position of `startTimestamp` in packed ownership.
              uint256 private constant _BITPOS_START_TIMESTAMP = 160;
              // The bit mask of the `burned` bit in packed ownership.
              uint256 private constant _BITMASK_BURNED = 1 << 224;
              // The bit position of the `nextInitialized` bit in packed ownership.
              uint256 private constant _BITPOS_NEXT_INITIALIZED = 225;
              // The bit mask of the `nextInitialized` bit in packed ownership.
              uint256 private constant _BITMASK_NEXT_INITIALIZED = 1 << 225;
              // The bit position of `extraData` in packed ownership.
              uint256 private constant _BITPOS_EXTRA_DATA = 232;
              // Mask of all 256 bits in a packed ownership except the 24 bits for `extraData`.
              uint256 private constant _BITMASK_EXTRA_DATA_COMPLEMENT = (1 << 232) - 1;
              // The mask of the lower 160 bits for addresses.
              uint256 private constant _BITMASK_ADDRESS = (1 << 160) - 1;
              // The maximum `quantity` that can be minted with {_mintERC2309}.
              // This limit is to prevent overflows on the address data entries.
              // For a limit of 5000, a total of 3.689e15 calls to {_mintERC2309}
              // is required to cause an overflow, which is unrealistic.
              uint256 private constant _MAX_MINT_ERC2309_QUANTITY_LIMIT = 5000;
              // The `Transfer` event signature is given by:
              // `keccak256(bytes("Transfer(address,address,uint256)"))`.
              bytes32 private constant _TRANSFER_EVENT_SIGNATURE =
                  0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;
              // =============================================================
              //                          CONSTRUCTOR
              // =============================================================
              function __ERC721A_init(string memory name_, string memory symbol_) internal onlyInitializingERC721A {
                  __ERC721A_init_unchained(name_, symbol_);
              }
              function __ERC721A_init_unchained(string memory name_, string memory symbol_) internal onlyInitializingERC721A {
                  ERC721AStorage.layout()._name = name_;
                  ERC721AStorage.layout()._symbol = symbol_;
                  ERC721AStorage.layout()._currentIndex = _startTokenId();
              }
              // =============================================================
              //                   TOKEN COUNTING OPERATIONS
              // =============================================================
              /**
               * @dev Returns the starting token ID.
               * To change the starting token ID, please override this function.
               */
              function _startTokenId() internal view virtual returns (uint256) {
                  return 0;
              }
              /**
               * @dev Returns the next token ID to be minted.
               */
              function _nextTokenId() internal view virtual returns (uint256) {
                  return ERC721AStorage.layout()._currentIndex;
              }
              /**
               * @dev Returns the total number of tokens in existence.
               * Burned tokens will reduce the count.
               * To get the total number of tokens minted, please see {_totalMinted}.
               */
              function totalSupply() public view virtual override returns (uint256) {
                  // Counter underflow is impossible as _burnCounter cannot be incremented
                  // more than `_currentIndex - _startTokenId()` times.
                  unchecked {
                      return ERC721AStorage.layout()._currentIndex - ERC721AStorage.layout()._burnCounter - _startTokenId();
                  }
              }
              /**
               * @dev Returns the total amount of tokens minted in the contract.
               */
              function _totalMinted() internal view virtual returns (uint256) {
                  // Counter underflow is impossible as `_currentIndex` does not decrement,
                  // and it is initialized to `_startTokenId()`.
                  unchecked {
                      return ERC721AStorage.layout()._currentIndex - _startTokenId();
                  }
              }
              /**
               * @dev Returns the total number of tokens burned.
               */
              function _totalBurned() internal view virtual returns (uint256) {
                  return ERC721AStorage.layout()._burnCounter;
              }
              // =============================================================
              //                    ADDRESS DATA OPERATIONS
              // =============================================================
              /**
               * @dev Returns the number of tokens in `owner`'s account.
               */
              function balanceOf(address owner) public view virtual override returns (uint256) {
                  if (owner == address(0)) revert BalanceQueryForZeroAddress();
                  return ERC721AStorage.layout()._packedAddressData[owner] & _BITMASK_ADDRESS_DATA_ENTRY;
              }
              /**
               * Returns the number of tokens minted by `owner`.
               */
              function _numberMinted(address owner) internal view returns (uint256) {
                  return
                      (ERC721AStorage.layout()._packedAddressData[owner] >> _BITPOS_NUMBER_MINTED) & _BITMASK_ADDRESS_DATA_ENTRY;
              }
              /**
               * Returns the number of tokens burned by or on behalf of `owner`.
               */
              function _numberBurned(address owner) internal view returns (uint256) {
                  return
                      (ERC721AStorage.layout()._packedAddressData[owner] >> _BITPOS_NUMBER_BURNED) & _BITMASK_ADDRESS_DATA_ENTRY;
              }
              /**
               * Returns the auxiliary data for `owner`. (e.g. number of whitelist mint slots used).
               */
              function _getAux(address owner) internal view returns (uint64) {
                  return uint64(ERC721AStorage.layout()._packedAddressData[owner] >> _BITPOS_AUX);
              }
              /**
               * Sets the auxiliary data for `owner`. (e.g. number of whitelist mint slots used).
               * If there are multiple variables, please pack them into a uint64.
               */
              function _setAux(address owner, uint64 aux) internal virtual {
                  uint256 packed = ERC721AStorage.layout()._packedAddressData[owner];
                  uint256 auxCasted;
                  // Cast `aux` with assembly to avoid redundant masking.
                  assembly {
                      auxCasted := aux
                  }
                  packed = (packed & _BITMASK_AUX_COMPLEMENT) | (auxCasted << _BITPOS_AUX);
                  ERC721AStorage.layout()._packedAddressData[owner] = packed;
              }
              // =============================================================
              //                            IERC165
              // =============================================================
              /**
               * @dev Returns true if this contract implements the interface defined by
               * `interfaceId`. See the corresponding
               * [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)
               * to learn more about how these ids are created.
               *
               * This function call must use less than 30000 gas.
               */
              function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
                  // The interface IDs are constants representing the first 4 bytes
                  // of the XOR of all function selectors in the interface.
                  // See: [ERC165](https://eips.ethereum.org/EIPS/eip-165)
                  // (e.g. `bytes4(i.functionA.selector ^ i.functionB.selector ^ ...)`)
                  return
                      interfaceId == 0x01ffc9a7 || // ERC165 interface ID for ERC165.
                      interfaceId == 0x80ac58cd || // ERC165 interface ID for ERC721.
                      interfaceId == 0x5b5e139f; // ERC165 interface ID for ERC721Metadata.
              }
              // =============================================================
              //                        IERC721Metadata
              // =============================================================
              /**
               * @dev Returns the token collection name.
               */
              function name() public view virtual override returns (string memory) {
                  return ERC721AStorage.layout()._name;
              }
              /**
               * @dev Returns the token collection symbol.
               */
              function symbol() public view virtual override returns (string memory) {
                  return ERC721AStorage.layout()._symbol;
              }
              /**
               * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
               */
              function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
                  if (!_exists(tokenId)) revert URIQueryForNonexistentToken();
                  string memory baseURI = _baseURI();
                  return bytes(baseURI).length != 0 ? string(abi.encodePacked(baseURI, _toString(tokenId))) : '';
              }
              /**
               * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
               * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
               * by default, it can be overridden in child contracts.
               */
              function _baseURI() internal view virtual returns (string memory) {
                  return '';
              }
              // =============================================================
              //                     OWNERSHIPS OPERATIONS
              // =============================================================
              /**
               * @dev Returns the owner of the `tokenId` token.
               *
               * Requirements:
               *
               * - `tokenId` must exist.
               */
              function ownerOf(uint256 tokenId) public view virtual override returns (address) {
                  return address(uint160(_packedOwnershipOf(tokenId)));
              }
              /**
               * @dev Gas spent here starts off proportional to the maximum mint batch size.
               * It gradually moves to O(1) as tokens get transferred around over time.
               */
              function _ownershipOf(uint256 tokenId) internal view virtual returns (TokenOwnership memory) {
                  return _unpackedOwnership(_packedOwnershipOf(tokenId));
              }
              /**
               * @dev Returns the unpacked `TokenOwnership` struct at `index`.
               */
              function _ownershipAt(uint256 index) internal view virtual returns (TokenOwnership memory) {
                  return _unpackedOwnership(ERC721AStorage.layout()._packedOwnerships[index]);
              }
              /**
               * @dev Initializes the ownership slot minted at `index` for efficiency purposes.
               */
              function _initializeOwnershipAt(uint256 index) internal virtual {
                  if (ERC721AStorage.layout()._packedOwnerships[index] == 0) {
                      ERC721AStorage.layout()._packedOwnerships[index] = _packedOwnershipOf(index);
                  }
              }
              /**
               * Returns the packed ownership data of `tokenId`.
               */
              function _packedOwnershipOf(uint256 tokenId) private view returns (uint256) {
                  uint256 curr = tokenId;
                  unchecked {
                      if (_startTokenId() <= curr)
                          if (curr < ERC721AStorage.layout()._currentIndex) {
                              uint256 packed = ERC721AStorage.layout()._packedOwnerships[curr];
                              // If not burned.
                              if (packed & _BITMASK_BURNED == 0) {
                                  // Invariant:
                                  // There will always be an initialized ownership slot
                                  // (i.e. `ownership.addr != address(0) && ownership.burned == false`)
                                  // before an unintialized ownership slot
                                  // (i.e. `ownership.addr == address(0) && ownership.burned == false`)
                                  // Hence, `curr` will not underflow.
                                  //
                                  // We can directly compare the packed value.
                                  // If the address is zero, packed will be zero.
                                  while (packed == 0) {
                                      packed = ERC721AStorage.layout()._packedOwnerships[--curr];
                                  }
                                  return packed;
                              }
                          }
                  }
                  revert OwnerQueryForNonexistentToken();
              }
              /**
               * @dev Returns the unpacked `TokenOwnership` struct from `packed`.
               */
              function _unpackedOwnership(uint256 packed) private pure returns (TokenOwnership memory ownership) {
                  ownership.addr = address(uint160(packed));
                  ownership.startTimestamp = uint64(packed >> _BITPOS_START_TIMESTAMP);
                  ownership.burned = packed & _BITMASK_BURNED != 0;
                  ownership.extraData = uint24(packed >> _BITPOS_EXTRA_DATA);
              }
              /**
               * @dev Packs ownership data into a single uint256.
               */
              function _packOwnershipData(address owner, uint256 flags) private view returns (uint256 result) {
                  assembly {
                      // Mask `owner` to the lower 160 bits, in case the upper bits somehow aren't clean.
                      owner := and(owner, _BITMASK_ADDRESS)
                      // `owner | (block.timestamp << _BITPOS_START_TIMESTAMP) | flags`.
                      result := or(owner, or(shl(_BITPOS_START_TIMESTAMP, timestamp()), flags))
                  }
              }
              /**
               * @dev Returns the `nextInitialized` flag set if `quantity` equals 1.
               */
              function _nextInitializedFlag(uint256 quantity) private pure returns (uint256 result) {
                  // For branchless setting of the `nextInitialized` flag.
                  assembly {
                      // `(quantity == 1) << _BITPOS_NEXT_INITIALIZED`.
                      result := shl(_BITPOS_NEXT_INITIALIZED, eq(quantity, 1))
                  }
              }
              // =============================================================
              //                      APPROVAL OPERATIONS
              // =============================================================
              /**
               * @dev Gives permission to `to` to transfer `tokenId` token to another account.
               * The approval is cleared when the token is transferred.
               *
               * Only a single account can be approved at a time, so approving the
               * zero address clears previous approvals.
               *
               * Requirements:
               *
               * - The caller must own the token or be an approved operator.
               * - `tokenId` must exist.
               *
               * Emits an {Approval} event.
               */
              function approve(address to, uint256 tokenId) public virtual override {
                  address owner = ownerOf(tokenId);
                  if (_msgSenderERC721A() != owner)
                      if (!isApprovedForAll(owner, _msgSenderERC721A())) {
                          revert ApprovalCallerNotOwnerNorApproved();
                      }
                  ERC721AStorage.layout()._tokenApprovals[tokenId].value = to;
                  emit Approval(owner, to, tokenId);
              }
              /**
               * @dev Returns the account approved for `tokenId` token.
               *
               * Requirements:
               *
               * - `tokenId` must exist.
               */
              function getApproved(uint256 tokenId) public view virtual override returns (address) {
                  if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();
                  return ERC721AStorage.layout()._tokenApprovals[tokenId].value;
              }
              /**
               * @dev Approve or remove `operator` as an operator for the caller.
               * Operators can call {transferFrom} or {safeTransferFrom}
               * for any token owned by the caller.
               *
               * Requirements:
               *
               * - The `operator` cannot be the caller.
               *
               * Emits an {ApprovalForAll} event.
               */
              function setApprovalForAll(address operator, bool approved) public virtual override {
                  if (operator == _msgSenderERC721A()) revert ApproveToCaller();
                  ERC721AStorage.layout()._operatorApprovals[_msgSenderERC721A()][operator] = approved;
                  emit ApprovalForAll(_msgSenderERC721A(), operator, approved);
              }
              /**
               * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
               *
               * See {setApprovalForAll}.
               */
              function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
                  return ERC721AStorage.layout()._operatorApprovals[owner][operator];
              }
              /**
               * @dev Returns whether `tokenId` exists.
               *
               * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
               *
               * Tokens start existing when they are minted. See {_mint}.
               */
              function _exists(uint256 tokenId) internal view virtual returns (bool) {
                  return
                      _startTokenId() <= tokenId &&
                      tokenId < ERC721AStorage.layout()._currentIndex && // If within bounds,
                      ERC721AStorage.layout()._packedOwnerships[tokenId] & _BITMASK_BURNED == 0; // and not burned.
              }
              /**
               * @dev Returns whether `msgSender` is equal to `approvedAddress` or `owner`.
               */
              function _isSenderApprovedOrOwner(
                  address approvedAddress,
                  address owner,
                  address msgSender
              ) private pure returns (bool result) {
                  assembly {
                      // Mask `owner` to the lower 160 bits, in case the upper bits somehow aren't clean.
                      owner := and(owner, _BITMASK_ADDRESS)
                      // Mask `msgSender` to the lower 160 bits, in case the upper bits somehow aren't clean.
                      msgSender := and(msgSender, _BITMASK_ADDRESS)
                      // `msgSender == owner || msgSender == approvedAddress`.
                      result := or(eq(msgSender, owner), eq(msgSender, approvedAddress))
                  }
              }
              /**
               * @dev Returns the storage slot and value for the approved address of `tokenId`.
               */
              function _getApprovedSlotAndAddress(uint256 tokenId)
                  private
                  view
                  returns (uint256 approvedAddressSlot, address approvedAddress)
              {
                  ERC721AStorage.TokenApprovalRef storage tokenApproval = ERC721AStorage.layout()._tokenApprovals[tokenId];
                  // The following is equivalent to `approvedAddress = _tokenApprovals[tokenId].value`.
                  assembly {
                      approvedAddressSlot := tokenApproval.slot
                      approvedAddress := sload(approvedAddressSlot)
                  }
              }
              // =============================================================
              //                      TRANSFER OPERATIONS
              // =============================================================
              /**
               * @dev Transfers `tokenId` from `from` to `to`.
               *
               * Requirements:
               *
               * - `from` cannot be the zero address.
               * - `to` cannot be the zero address.
               * - `tokenId` token must be owned by `from`.
               * - If the caller is not `from`, it must be approved to move this token
               * by either {approve} or {setApprovalForAll}.
               *
               * Emits a {Transfer} event.
               */
              function transferFrom(
                  address from,
                  address to,
                  uint256 tokenId
              ) public virtual override {
                  uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);
                  if (address(uint160(prevOwnershipPacked)) != from) revert TransferFromIncorrectOwner();
                  (uint256 approvedAddressSlot, address approvedAddress) = _getApprovedSlotAndAddress(tokenId);
                  // The nested ifs save around 20+ gas over a compound boolean condition.
                  if (!_isSenderApprovedOrOwner(approvedAddress, from, _msgSenderERC721A()))
                      if (!isApprovedForAll(from, _msgSenderERC721A())) revert TransferCallerNotOwnerNorApproved();
                  if (to == address(0)) revert TransferToZeroAddress();
                  _beforeTokenTransfers(from, to, tokenId, 1);
                  // Clear approvals from the previous owner.
                  assembly {
                      if approvedAddress {
                          // This is equivalent to `delete _tokenApprovals[tokenId]`.
                          sstore(approvedAddressSlot, 0)
                      }
                  }
                  // Underflow of the sender's balance is impossible because we check for
                  // ownership above and the recipient's balance can't realistically overflow.
                  // Counter overflow is incredibly unrealistic as `tokenId` would have to be 2**256.
                  unchecked {
                      // We can directly increment and decrement the balances.
                      --ERC721AStorage.layout()._packedAddressData[from]; // Updates: `balance -= 1`.
                      ++ERC721AStorage.layout()._packedAddressData[to]; // Updates: `balance += 1`.
                      // Updates:
                      // - `address` to the next owner.
                      // - `startTimestamp` to the timestamp of transfering.
                      // - `burned` to `false`.
                      // - `nextInitialized` to `true`.
                      ERC721AStorage.layout()._packedOwnerships[tokenId] = _packOwnershipData(
                          to,
                          _BITMASK_NEXT_INITIALIZED | _nextExtraData(from, to, prevOwnershipPacked)
                      );
                      // If the next slot may not have been initialized (i.e. `nextInitialized == false`) .
                      if (prevOwnershipPacked & _BITMASK_NEXT_INITIALIZED == 0) {
                          uint256 nextTokenId = tokenId + 1;
                          // If the next slot's address is zero and not burned (i.e. packed value is zero).
                          if (ERC721AStorage.layout()._packedOwnerships[nextTokenId] == 0) {
                              // If the next slot is within bounds.
                              if (nextTokenId != ERC721AStorage.layout()._currentIndex) {
                                  // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.
                                  ERC721AStorage.layout()._packedOwnerships[nextTokenId] = prevOwnershipPacked;
                              }
                          }
                      }
                  }
                  emit Transfer(from, to, tokenId);
                  _afterTokenTransfers(from, to, tokenId, 1);
              }
              /**
               * @dev Equivalent to `safeTransferFrom(from, to, tokenId, '')`.
               */
              function safeTransferFrom(
                  address from,
                  address to,
                  uint256 tokenId
              ) public virtual override {
                  safeTransferFrom(from, to, tokenId, '');
              }
              /**
               * @dev Safely transfers `tokenId` token from `from` to `to`.
               *
               * Requirements:
               *
               * - `from` cannot be the zero address.
               * - `to` cannot be the zero address.
               * - `tokenId` token must exist and be owned by `from`.
               * - If the caller is not `from`, it must be approved to move this token
               * by either {approve} or {setApprovalForAll}.
               * - If `to` refers to a smart contract, it must implement
               * {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
               *
               * Emits a {Transfer} event.
               */
              function safeTransferFrom(
                  address from,
                  address to,
                  uint256 tokenId,
                  bytes memory _data
              ) public virtual override {
                  transferFrom(from, to, tokenId);
                  if (to.code.length != 0)
                      if (!_checkContractOnERC721Received(from, to, tokenId, _data)) {
                          revert TransferToNonERC721ReceiverImplementer();
                      }
              }
              /**
               * @dev Hook that is called before a set of serially-ordered token IDs
               * are about to be transferred. This includes minting.
               * And also called before burning one token.
               *
               * `startTokenId` - the first token ID to be transferred.
               * `quantity` - the amount to be transferred.
               *
               * Calling conditions:
               *
               * - When `from` and `to` are both non-zero, `from`'s `tokenId` will be
               * transferred to `to`.
               * - When `from` is zero, `tokenId` will be minted for `to`.
               * - When `to` is zero, `tokenId` will be burned by `from`.
               * - `from` and `to` are never both zero.
               */
              function _beforeTokenTransfers(
                  address from,
                  address to,
                  uint256 startTokenId,
                  uint256 quantity
              ) internal virtual {}
              /**
               * @dev Hook that is called after a set of serially-ordered token IDs
               * have been transferred. This includes minting.
               * And also called after one token has been burned.
               *
               * `startTokenId` - the first token ID to be transferred.
               * `quantity` - the amount to be transferred.
               *
               * Calling conditions:
               *
               * - When `from` and `to` are both non-zero, `from`'s `tokenId` has been
               * transferred to `to`.
               * - When `from` is zero, `tokenId` has been minted for `to`.
               * - When `to` is zero, `tokenId` has been burned by `from`.
               * - `from` and `to` are never both zero.
               */
              function _afterTokenTransfers(
                  address from,
                  address to,
                  uint256 startTokenId,
                  uint256 quantity
              ) internal virtual {}
              /**
               * @dev Private function to invoke {IERC721Receiver-onERC721Received} on a target contract.
               *
               * `from` - Previous owner of the given token ID.
               * `to` - Target address that will receive the token.
               * `tokenId` - Token ID to be transferred.
               * `_data` - Optional data to send along with the call.
               *
               * Returns whether the call correctly returned the expected magic value.
               */
              function _checkContractOnERC721Received(
                  address from,
                  address to,
                  uint256 tokenId,
                  bytes memory _data
              ) private returns (bool) {
                  try
                      ERC721A__IERC721ReceiverUpgradeable(to).onERC721Received(_msgSenderERC721A(), from, tokenId, _data)
                  returns (bytes4 retval) {
                      return retval == ERC721A__IERC721ReceiverUpgradeable(to).onERC721Received.selector;
                  } catch (bytes memory reason) {
                      if (reason.length == 0) {
                          revert TransferToNonERC721ReceiverImplementer();
                      } else {
                          assembly {
                              revert(add(32, reason), mload(reason))
                          }
                      }
                  }
              }
              // =============================================================
              //                        MINT OPERATIONS
              // =============================================================
              /**
               * @dev Mints `quantity` tokens and transfers them to `to`.
               *
               * Requirements:
               *
               * - `to` cannot be the zero address.
               * - `quantity` must be greater than 0.
               *
               * Emits a {Transfer} event for each mint.
               */
              function _mint(address to, uint256 quantity) internal virtual {
                  uint256 startTokenId = ERC721AStorage.layout()._currentIndex;
                  if (quantity == 0) revert MintZeroQuantity();
                  _beforeTokenTransfers(address(0), to, startTokenId, quantity);
                  // Overflows are incredibly unrealistic.
                  // `balance` and `numberMinted` have a maximum limit of 2**64.
                  // `tokenId` has a maximum limit of 2**256.
                  unchecked {
                      // Updates:
                      // - `balance += quantity`.
                      // - `numberMinted += quantity`.
                      //
                      // We can directly add to the `balance` and `numberMinted`.
                      ERC721AStorage.layout()._packedAddressData[to] += quantity * ((1 << _BITPOS_NUMBER_MINTED) | 1);
                      // Updates:
                      // - `address` to the owner.
                      // - `startTimestamp` to the timestamp of minting.
                      // - `burned` to `false`.
                      // - `nextInitialized` to `quantity == 1`.
                      ERC721AStorage.layout()._packedOwnerships[startTokenId] = _packOwnershipData(
                          to,
                          _nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)
                      );
                      uint256 toMasked;
                      uint256 end = startTokenId + quantity;
                      // Use assembly to loop and emit the `Transfer` event for gas savings.
                      // The duplicated `log4` removes an extra check and reduces stack juggling.
                      // The assembly, together with the surrounding Solidity code, have been
                      // delicately arranged to nudge the compiler into producing optimized opcodes.
                      assembly {
                          // Mask `to` to the lower 160 bits, in case the upper bits somehow aren't clean.
                          toMasked := and(to, _BITMASK_ADDRESS)
                          // Emit the `Transfer` event.
                          log4(
                              0, // Start of data (0, since no data).
                              0, // End of data (0, since no data).
                              _TRANSFER_EVENT_SIGNATURE, // Signature.
                              0, // `address(0)`.
                              toMasked, // `to`.
                              startTokenId // `tokenId`.
                          )
                          for {
                              let tokenId := add(startTokenId, 1)
                          } iszero(eq(tokenId, end)) {
                              tokenId := add(tokenId, 1)
                          } {
                              // Emit the `Transfer` event. Similar to above.
                              log4(0, 0, _TRANSFER_EVENT_SIGNATURE, 0, toMasked, tokenId)
                          }
                      }
                      if (toMasked == 0) revert MintToZeroAddress();
                      ERC721AStorage.layout()._currentIndex = end;
                  }
                  _afterTokenTransfers(address(0), to, startTokenId, quantity);
              }
              /**
               * @dev Mints `quantity` tokens and transfers them to `to`.
               *
               * This function is intended for efficient minting only during contract creation.
               *
               * It emits only one {ConsecutiveTransfer} as defined in
               * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309),
               * instead of a sequence of {Transfer} event(s).
               *
               * Calling this function outside of contract creation WILL make your contract
               * non-compliant with the ERC721 standard.
               * For full ERC721 compliance, substituting ERC721 {Transfer} event(s) with the ERC2309
               * {ConsecutiveTransfer} event is only permissible during contract creation.
               *
               * Requirements:
               *
               * - `to` cannot be the zero address.
               * - `quantity` must be greater than 0.
               *
               * Emits a {ConsecutiveTransfer} event.
               */
              function _mintERC2309(address to, uint256 quantity) internal virtual {
                  uint256 startTokenId = ERC721AStorage.layout()._currentIndex;
                  if (to == address(0)) revert MintToZeroAddress();
                  if (quantity == 0) revert MintZeroQuantity();
                  if (quantity > _MAX_MINT_ERC2309_QUANTITY_LIMIT) revert MintERC2309QuantityExceedsLimit();
                  _beforeTokenTransfers(address(0), to, startTokenId, quantity);
                  // Overflows are unrealistic due to the above check for `quantity` to be below the limit.
                  unchecked {
                      // Updates:
                      // - `balance += quantity`.
                      // - `numberMinted += quantity`.
                      //
                      // We can directly add to the `balance` and `numberMinted`.
                      ERC721AStorage.layout()._packedAddressData[to] += quantity * ((1 << _BITPOS_NUMBER_MINTED) | 1);
                      // Updates:
                      // - `address` to the owner.
                      // - `startTimestamp` to the timestamp of minting.
                      // - `burned` to `false`.
                      // - `nextInitialized` to `quantity == 1`.
                      ERC721AStorage.layout()._packedOwnerships[startTokenId] = _packOwnershipData(
                          to,
                          _nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)
                      );
                      emit ConsecutiveTransfer(startTokenId, startTokenId + quantity - 1, address(0), to);
                      ERC721AStorage.layout()._currentIndex = startTokenId + quantity;
                  }
                  _afterTokenTransfers(address(0), to, startTokenId, quantity);
              }
              /**
               * @dev Safely mints `quantity` tokens and transfers them to `to`.
               *
               * Requirements:
               *
               * - If `to` refers to a smart contract, it must implement
               * {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
               * - `quantity` must be greater than 0.
               *
               * See {_mint}.
               *
               * Emits a {Transfer} event for each mint.
               */
              function _safeMint(
                  address to,
                  uint256 quantity,
                  bytes memory _data
              ) internal virtual {
                  _mint(to, quantity);
                  unchecked {
                      if (to.code.length != 0) {
                          uint256 end = ERC721AStorage.layout()._currentIndex;
                          uint256 index = end - quantity;
                          do {
                              if (!_checkContractOnERC721Received(address(0), to, index++, _data)) {
                                  revert TransferToNonERC721ReceiverImplementer();
                              }
                          } while (index < end);
                          // Reentrancy protection.
                          if (ERC721AStorage.layout()._currentIndex != end) revert();
                      }
                  }
              }
              /**
               * @dev Equivalent to `_safeMint(to, quantity, '')`.
               */
              function _safeMint(address to, uint256 quantity) internal virtual {
                  _safeMint(to, quantity, '');
              }
              // =============================================================
              //                        BURN OPERATIONS
              // =============================================================
              /**
               * @dev Equivalent to `_burn(tokenId, false)`.
               */
              function _burn(uint256 tokenId) internal virtual {
                  _burn(tokenId, false);
              }
              /**
               * @dev Destroys `tokenId`.
               * The approval is cleared when the token is burned.
               *
               * Requirements:
               *
               * - `tokenId` must exist.
               *
               * Emits a {Transfer} event.
               */
              function _burn(uint256 tokenId, bool approvalCheck) internal virtual {
                  uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);
                  address from = address(uint160(prevOwnershipPacked));
                  (uint256 approvedAddressSlot, address approvedAddress) = _getApprovedSlotAndAddress(tokenId);
                  if (approvalCheck) {
                      // The nested ifs save around 20+ gas over a compound boolean condition.
                      if (!_isSenderApprovedOrOwner(approvedAddress, from, _msgSenderERC721A()))
                          if (!isApprovedForAll(from, _msgSenderERC721A())) revert TransferCallerNotOwnerNorApproved();
                  }
                  _beforeTokenTransfers(from, address(0), tokenId, 1);
                  // Clear approvals from the previous owner.
                  assembly {
                      if approvedAddress {
                          // This is equivalent to `delete _tokenApprovals[tokenId]`.
                          sstore(approvedAddressSlot, 0)
                      }
                  }
                  // Underflow of the sender's balance is impossible because we check for
                  // ownership above and the recipient's balance can't realistically overflow.
                  // Counter overflow is incredibly unrealistic as `tokenId` would have to be 2**256.
                  unchecked {
                      // Updates:
                      // - `balance -= 1`.
                      // - `numberBurned += 1`.
                      //
                      // We can directly decrement the balance, and increment the number burned.
                      // This is equivalent to `packed -= 1; packed += 1 << _BITPOS_NUMBER_BURNED;`.
                      ERC721AStorage.layout()._packedAddressData[from] += (1 << _BITPOS_NUMBER_BURNED) - 1;
                      // Updates:
                      // - `address` to the last owner.
                      // - `startTimestamp` to the timestamp of burning.
                      // - `burned` to `true`.
                      // - `nextInitialized` to `true`.
                      ERC721AStorage.layout()._packedOwnerships[tokenId] = _packOwnershipData(
                          from,
                          (_BITMASK_BURNED | _BITMASK_NEXT_INITIALIZED) | _nextExtraData(from, address(0), prevOwnershipPacked)
                      );
                      // If the next slot may not have been initialized (i.e. `nextInitialized == false`) .
                      if (prevOwnershipPacked & _BITMASK_NEXT_INITIALIZED == 0) {
                          uint256 nextTokenId = tokenId + 1;
                          // If the next slot's address is zero and not burned (i.e. packed value is zero).
                          if (ERC721AStorage.layout()._packedOwnerships[nextTokenId] == 0) {
                              // If the next slot is within bounds.
                              if (nextTokenId != ERC721AStorage.layout()._currentIndex) {
                                  // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.
                                  ERC721AStorage.layout()._packedOwnerships[nextTokenId] = prevOwnershipPacked;
                              }
                          }
                      }
                  }
                  emit Transfer(from, address(0), tokenId);
                  _afterTokenTransfers(from, address(0), tokenId, 1);
                  // Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.
                  unchecked {
                      ERC721AStorage.layout()._burnCounter++;
                  }
              }
              // =============================================================
              //                     EXTRA DATA OPERATIONS
              // =============================================================
              /**
               * @dev Directly sets the extra data for the ownership data `index`.
               */
              function _setExtraDataAt(uint256 index, uint24 extraData) internal virtual {
                  uint256 packed = ERC721AStorage.layout()._packedOwnerships[index];
                  if (packed == 0) revert OwnershipNotInitializedForExtraData();
                  uint256 extraDataCasted;
                  // Cast `extraData` with assembly to avoid redundant masking.
                  assembly {
                      extraDataCasted := extraData
                  }
                  packed = (packed & _BITMASK_EXTRA_DATA_COMPLEMENT) | (extraDataCasted << _BITPOS_EXTRA_DATA);
                  ERC721AStorage.layout()._packedOwnerships[index] = packed;
              }
              /**
               * @dev Called during each token transfer to set the 24bit `extraData` field.
               * Intended to be overridden by the cosumer contract.
               *
               * `previousExtraData` - the value of `extraData` before transfer.
               *
               * Calling conditions:
               *
               * - When `from` and `to` are both non-zero, `from`'s `tokenId` will be
               * transferred to `to`.
               * - When `from` is zero, `tokenId` will be minted for `to`.
               * - When `to` is zero, `tokenId` will be burned by `from`.
               * - `from` and `to` are never both zero.
               */
              function _extraData(
                  address from,
                  address to,
                  uint24 previousExtraData
              ) internal view virtual returns (uint24) {}
              /**
               * @dev Returns the next extra data for the packed ownership data.
               * The returned result is shifted into position.
               */
              function _nextExtraData(
                  address from,
                  address to,
                  uint256 prevOwnershipPacked
              ) private view returns (uint256) {
                  uint24 extraData = uint24(prevOwnershipPacked >> _BITPOS_EXTRA_DATA);
                  return uint256(_extraData(from, to, extraData)) << _BITPOS_EXTRA_DATA;
              }
              // =============================================================
              //                       OTHER OPERATIONS
              // =============================================================
              /**
               * @dev Returns the message sender (defaults to `msg.sender`).
               *
               * If you are writing GSN compatible contracts, you need to override this function.
               */
              function _msgSenderERC721A() internal view virtual returns (address) {
                  return msg.sender;
              }
              /**
               * @dev Converts a uint256 to its ASCII string decimal representation.
               */
              function _toString(uint256 value) internal pure virtual returns (string memory str) {
                  assembly {
                      // The maximum value of a uint256 contains 78 digits (1 byte per digit),
                      // but we allocate 0x80 bytes to keep the free memory pointer 32-byte word aligned.
                      // We will need 1 32-byte word to store the length,
                      // and 3 32-byte words to store a maximum of 78 digits. Total: 0x20 + 3 * 0x20 = 0x80.
                      str := add(mload(0x40), 0x80)
                      // Update the free memory pointer to allocate.
                      mstore(0x40, str)
                      // Cache the end of the memory to calculate the length later.
                      let end := str
                      // We write the string from rightmost digit to leftmost digit.
                      // The following is essentially a do-while loop that also handles the zero case.
                      // prettier-ignore
                      for { let temp := value } 1 {} {
                          str := sub(str, 1)
                          // Write the character to the pointer.
                          // The ASCII index of the '0' character is 48.
                          mstore8(str, add(48, mod(temp, 10)))
                          // Keep dividing `temp` until zero.
                          temp := div(temp, 10)
                          // prettier-ignore
                          if iszero(temp) { break }
                      }
                      let length := sub(end, str)
                      // Move the pointer 32 bytes leftwards to make room for the length.
                      str := sub(str, 0x20)
                      // Store the length.
                      mstore(str, length)
                  }
              }
          }
          // SPDX-License-Identifier: MIT
          // ERC721A Contracts v4.2.2
          // Creator: Chiru Labs
          pragma solidity ^0.8.4;
          import './IERC721AQueryableUpgradeable.sol';
          import '../ERC721AUpgradeable.sol';
          import '../ERC721A__Initializable.sol';
          /**
           * @title ERC721AQueryable.
           *
           * @dev ERC721A subclass with convenience query functions.
           */
          abstract contract ERC721AQueryableUpgradeable is
              ERC721A__Initializable,
              ERC721AUpgradeable,
              IERC721AQueryableUpgradeable
          {
              function __ERC721AQueryable_init() internal onlyInitializingERC721A {
                  __ERC721AQueryable_init_unchained();
              }
              function __ERC721AQueryable_init_unchained() internal onlyInitializingERC721A {}
              /**
               * @dev Returns the `TokenOwnership` struct at `tokenId` without reverting.
               *
               * If the `tokenId` is out of bounds:
               *
               * - `addr = address(0)`
               * - `startTimestamp = 0`
               * - `burned = false`
               * - `extraData = 0`
               *
               * If the `tokenId` is burned:
               *
               * - `addr = <Address of owner before token was burned>`
               * - `startTimestamp = <Timestamp when token was burned>`
               * - `burned = true`
               * - `extraData = <Extra data when token was burned>`
               *
               * Otherwise:
               *
               * - `addr = <Address of owner>`
               * - `startTimestamp = <Timestamp of start of ownership>`
               * - `burned = false`
               * - `extraData = <Extra data at start of ownership>`
               */
              function explicitOwnershipOf(uint256 tokenId) public view virtual override returns (TokenOwnership memory) {
                  TokenOwnership memory ownership;
                  if (tokenId < _startTokenId() || tokenId >= _nextTokenId()) {
                      return ownership;
                  }
                  ownership = _ownershipAt(tokenId);
                  if (ownership.burned) {
                      return ownership;
                  }
                  return _ownershipOf(tokenId);
              }
              /**
               * @dev Returns an array of `TokenOwnership` structs at `tokenIds` in order.
               * See {ERC721AQueryable-explicitOwnershipOf}
               */
              function explicitOwnershipsOf(uint256[] calldata tokenIds)
                  external
                  view
                  virtual
                  override
                  returns (TokenOwnership[] memory)
              {
                  unchecked {
                      uint256 tokenIdsLength = tokenIds.length;
                      TokenOwnership[] memory ownerships = new TokenOwnership[](tokenIdsLength);
                      for (uint256 i; i != tokenIdsLength; ++i) {
                          ownerships[i] = explicitOwnershipOf(tokenIds[i]);
                      }
                      return ownerships;
                  }
              }
              /**
               * @dev Returns an array of token IDs owned by `owner`,
               * in the range [`start`, `stop`)
               * (i.e. `start <= tokenId < stop`).
               *
               * This function allows for tokens to be queried if the collection
               * grows too big for a single call of {ERC721AQueryable-tokensOfOwner}.
               *
               * Requirements:
               *
               * - `start < stop`
               */
              function tokensOfOwnerIn(
                  address owner,
                  uint256 start,
                  uint256 stop
              ) external view virtual override returns (uint256[] memory) {
                  unchecked {
                      if (start >= stop) revert InvalidQueryRange();
                      uint256 tokenIdsIdx;
                      uint256 stopLimit = _nextTokenId();
                      // Set `start = max(start, _startTokenId())`.
                      if (start < _startTokenId()) {
                          start = _startTokenId();
                      }
                      // Set `stop = min(stop, stopLimit)`.
                      if (stop > stopLimit) {
                          stop = stopLimit;
                      }
                      uint256 tokenIdsMaxLength = balanceOf(owner);
                      // Set `tokenIdsMaxLength = min(balanceOf(owner), stop - start)`,
                      // to cater for cases where `balanceOf(owner)` is too big.
                      if (start < stop) {
                          uint256 rangeLength = stop - start;
                          if (rangeLength < tokenIdsMaxLength) {
                              tokenIdsMaxLength = rangeLength;
                          }
                      } else {
                          tokenIdsMaxLength = 0;
                      }
                      uint256[] memory tokenIds = new uint256[](tokenIdsMaxLength);
                      if (tokenIdsMaxLength == 0) {
                          return tokenIds;
                      }
                      // We need to call `explicitOwnershipOf(start)`,
                      // because the slot at `start` may not be initialized.
                      TokenOwnership memory ownership = explicitOwnershipOf(start);
                      address currOwnershipAddr;
                      // If the starting slot exists (i.e. not burned), initialize `currOwnershipAddr`.
                      // `ownership.address` will not be zero, as `start` is clamped to the valid token ID range.
                      if (!ownership.burned) {
                          currOwnershipAddr = ownership.addr;
                      }
                      for (uint256 i = start; i != stop && tokenIdsIdx != tokenIdsMaxLength; ++i) {
                          ownership = _ownershipAt(i);
                          if (ownership.burned) {
                              continue;
                          }
                          if (ownership.addr != address(0)) {
                              currOwnershipAddr = ownership.addr;
                          }
                          if (currOwnershipAddr == owner) {
                              tokenIds[tokenIdsIdx++] = i;
                          }
                      }
                      // Downsize the array to fit.
                      assembly {
                          mstore(tokenIds, tokenIdsIdx)
                      }
                      return tokenIds;
                  }
              }
              /**
               * @dev Returns an array of token IDs owned by `owner`.
               *
               * This function scans the ownership mapping and is O(`totalSupply`) in complexity.
               * It is meant to be called off-chain.
               *
               * See {ERC721AQueryable-tokensOfOwnerIn} for splitting the scan into
               * multiple smaller scans if the collection is large enough to cause
               * an out-of-gas error (10K collections should be fine).
               */
              function tokensOfOwner(address owner) external view virtual override returns (uint256[] memory) {
                  unchecked {
                      uint256 tokenIdsIdx;
                      address currOwnershipAddr;
                      uint256 tokenIdsLength = balanceOf(owner);
                      uint256[] memory tokenIds = new uint256[](tokenIdsLength);
                      TokenOwnership memory ownership;
                      for (uint256 i = _startTokenId(); tokenIdsIdx != tokenIdsLength; ++i) {
                          ownership = _ownershipAt(i);
                          if (ownership.burned) {
                              continue;
                          }
                          if (ownership.addr != address(0)) {
                              currOwnershipAddr = ownership.addr;
                          }
                          if (currOwnershipAddr == owner) {
                              tokenIds[tokenIdsIdx++] = i;
                          }
                      }
                      return tokenIds;
                  }
              }
          }
          // SPDX-License-Identifier: MIT
          // ERC721A Contracts v4.2.2
          // Creator: Chiru Labs
          pragma solidity ^0.8.4;
          import '../IERC721AUpgradeable.sol';
          /**
           * @dev Interface of ERC721AQueryable.
           */
          interface IERC721AQueryableUpgradeable is IERC721AUpgradeable {
              /**
               * Invalid query range (`start` >= `stop`).
               */
              error InvalidQueryRange();
              /**
               * @dev Returns the `TokenOwnership` struct at `tokenId` without reverting.
               *
               * If the `tokenId` is out of bounds:
               *
               * - `addr = address(0)`
               * - `startTimestamp = 0`
               * - `burned = false`
               * - `extraData = 0`
               *
               * If the `tokenId` is burned:
               *
               * - `addr = <Address of owner before token was burned>`
               * - `startTimestamp = <Timestamp when token was burned>`
               * - `burned = true`
               * - `extraData = <Extra data when token was burned>`
               *
               * Otherwise:
               *
               * - `addr = <Address of owner>`
               * - `startTimestamp = <Timestamp of start of ownership>`
               * - `burned = false`
               * - `extraData = <Extra data at start of ownership>`
               */
              function explicitOwnershipOf(uint256 tokenId) external view returns (TokenOwnership memory);
              /**
               * @dev Returns an array of `TokenOwnership` structs at `tokenIds` in order.
               * See {ERC721AQueryable-explicitOwnershipOf}
               */
              function explicitOwnershipsOf(uint256[] memory tokenIds) external view returns (TokenOwnership[] memory);
              /**
               * @dev Returns an array of token IDs owned by `owner`,
               * in the range [`start`, `stop`)
               * (i.e. `start <= tokenId < stop`).
               *
               * This function allows for tokens to be queried if the collection
               * grows too big for a single call of {ERC721AQueryable-tokensOfOwner}.
               *
               * Requirements:
               *
               * - `start < stop`
               */
              function tokensOfOwnerIn(
                  address owner,
                  uint256 start,
                  uint256 stop
              ) external view returns (uint256[] memory);
              /**
               * @dev Returns an array of token IDs owned by `owner`.
               *
               * This function scans the ownership mapping and is O(`totalSupply`) in complexity.
               * It is meant to be called off-chain.
               *
               * See {ERC721AQueryable-tokensOfOwnerIn} for splitting the scan into
               * multiple smaller scans if the collection is large enough to cause
               * an out-of-gas error (10K collections should be fine).
               */
              function tokensOfOwner(address owner) external view returns (uint256[] memory);
          }
          // SPDX-License-Identifier: MIT
          // ERC721A Contracts v4.2.2
          // Creator: Chiru Labs
          pragma solidity ^0.8.4;
          /**
           * @dev Interface of ERC721A.
           */
          interface IERC721AUpgradeable {
              /**
               * The caller must own the token or be an approved operator.
               */
              error ApprovalCallerNotOwnerNorApproved();
              /**
               * The token does not exist.
               */
              error ApprovalQueryForNonexistentToken();
              /**
               * The caller cannot approve to their own address.
               */
              error ApproveToCaller();
              /**
               * Cannot query the balance for the zero address.
               */
              error BalanceQueryForZeroAddress();
              /**
               * Cannot mint to the zero address.
               */
              error MintToZeroAddress();
              /**
               * The quantity of tokens minted must be more than zero.
               */
              error MintZeroQuantity();
              /**
               * The token does not exist.
               */
              error OwnerQueryForNonexistentToken();
              /**
               * The caller must own the token or be an approved operator.
               */
              error TransferCallerNotOwnerNorApproved();
              /**
               * The token must be owned by `from`.
               */
              error TransferFromIncorrectOwner();
              /**
               * Cannot safely transfer to a contract that does not implement the
               * ERC721Receiver interface.
               */
              error TransferToNonERC721ReceiverImplementer();
              /**
               * Cannot transfer to the zero address.
               */
              error TransferToZeroAddress();
              /**
               * The token does not exist.
               */
              error URIQueryForNonexistentToken();
              /**
               * The `quantity` minted with ERC2309 exceeds the safety limit.
               */
              error MintERC2309QuantityExceedsLimit();
              /**
               * The `extraData` cannot be set on an unintialized ownership slot.
               */
              error OwnershipNotInitializedForExtraData();
              // =============================================================
              //                            STRUCTS
              // =============================================================
              struct TokenOwnership {
                  // The address of the owner.
                  address addr;
                  // Stores the start time of ownership with minimal overhead for tokenomics.
                  uint64 startTimestamp;
                  // Whether the token has been burned.
                  bool burned;
                  // Arbitrary data similar to `startTimestamp` that can be set via {_extraData}.
                  uint24 extraData;
              }
              // =============================================================
              //                         TOKEN COUNTERS
              // =============================================================
              /**
               * @dev Returns the total number of tokens in existence.
               * Burned tokens will reduce the count.
               * To get the total number of tokens minted, please see {_totalMinted}.
               */
              function totalSupply() external view returns (uint256);
              // =============================================================
              //                            IERC165
              // =============================================================
              /**
               * @dev Returns true if this contract implements the interface defined by
               * `interfaceId`. See the corresponding
               * [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)
               * to learn more about how these ids are created.
               *
               * This function call must use less than 30000 gas.
               */
              function supportsInterface(bytes4 interfaceId) external view returns (bool);
              // =============================================================
              //                            IERC721
              // =============================================================
              /**
               * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
               */
              event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
              /**
               * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
               */
              event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
              /**
               * @dev Emitted when `owner` enables or disables
               * (`approved`) `operator` to manage all of its assets.
               */
              event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
              /**
               * @dev Returns the number of tokens in `owner`'s account.
               */
              function balanceOf(address owner) external view returns (uint256 balance);
              /**
               * @dev Returns the owner of the `tokenId` token.
               *
               * Requirements:
               *
               * - `tokenId` must exist.
               */
              function ownerOf(uint256 tokenId) external view returns (address owner);
              /**
               * @dev Safely transfers `tokenId` token from `from` to `to`,
               * checking first that contract recipients are aware of the ERC721 protocol
               * to prevent tokens from being forever locked.
               *
               * Requirements:
               *
               * - `from` cannot be the zero address.
               * - `to` cannot be the zero address.
               * - `tokenId` token must exist and be owned by `from`.
               * - If the caller is not `from`, it must be have been allowed to move
               * this token by either {approve} or {setApprovalForAll}.
               * - If `to` refers to a smart contract, it must implement
               * {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
               *
               * Emits a {Transfer} event.
               */
              function safeTransferFrom(
                  address from,
                  address to,
                  uint256 tokenId,
                  bytes calldata data
              ) external;
              /**
               * @dev Equivalent to `safeTransferFrom(from, to, tokenId, '')`.
               */
              function safeTransferFrom(
                  address from,
                  address to,
                  uint256 tokenId
              ) external;
              /**
               * @dev Transfers `tokenId` from `from` to `to`.
               *
               * WARNING: Usage of this method is discouraged, use {safeTransferFrom}
               * whenever possible.
               *
               * Requirements:
               *
               * - `from` cannot be the zero address.
               * - `to` cannot be the zero address.
               * - `tokenId` token must be owned by `from`.
               * - If the caller is not `from`, it must be approved to move this token
               * by either {approve} or {setApprovalForAll}.
               *
               * Emits a {Transfer} event.
               */
              function transferFrom(
                  address from,
                  address to,
                  uint256 tokenId
              ) external;
              /**
               * @dev Gives permission to `to` to transfer `tokenId` token to another account.
               * The approval is cleared when the token is transferred.
               *
               * Only a single account can be approved at a time, so approving the
               * zero address clears previous approvals.
               *
               * Requirements:
               *
               * - The caller must own the token or be an approved operator.
               * - `tokenId` must exist.
               *
               * Emits an {Approval} event.
               */
              function approve(address to, uint256 tokenId) external;
              /**
               * @dev Approve or remove `operator` as an operator for the caller.
               * Operators can call {transferFrom} or {safeTransferFrom}
               * for any token owned by the caller.
               *
               * Requirements:
               *
               * - The `operator` cannot be the caller.
               *
               * Emits an {ApprovalForAll} event.
               */
              function setApprovalForAll(address operator, bool _approved) external;
              /**
               * @dev Returns the account approved for `tokenId` token.
               *
               * Requirements:
               *
               * - `tokenId` must exist.
               */
              function getApproved(uint256 tokenId) external view returns (address operator);
              /**
               * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
               *
               * See {setApprovalForAll}.
               */
              function isApprovedForAll(address owner, address operator) external view returns (bool);
              // =============================================================
              //                        IERC721Metadata
              // =============================================================
              /**
               * @dev Returns the token collection name.
               */
              function name() external view returns (string memory);
              /**
               * @dev Returns the token collection symbol.
               */
              function symbol() external view returns (string memory);
              /**
               * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
               */
              function tokenURI(uint256 tokenId) external view returns (string memory);
              // =============================================================
              //                           IERC2309
              // =============================================================
              /**
               * @dev Emitted when tokens in `fromTokenId` to `toTokenId`
               * (inclusive) is transferred from `from` to `to`, as defined in the
               * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309) standard.
               *
               * See {_mintERC2309} for more details.
               */
              event ConsecutiveTransfer(uint256 indexed fromTokenId, uint256 toTokenId, address indexed from, address indexed to);
          }
          

          File 5 of 5: OperatorFilterRegistry
          // SPDX-License-Identifier: MIT
          // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
          pragma solidity ^0.8.0;
          import "../utils/Context.sol";
          /**
           * @dev Contract module which provides a basic access control mechanism, where
           * there is an account (an owner) that can be granted exclusive access to
           * specific functions.
           *
           * By default, the owner account will be the one that deploys the contract. This
           * can later be changed with {transferOwnership}.
           *
           * This module is used through inheritance. It will make available the modifier
           * `onlyOwner`, which can be applied to your functions to restrict their use to
           * the owner.
           */
          abstract contract Ownable is Context {
              address private _owner;
              event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
              /**
               * @dev Initializes the contract setting the deployer as the initial owner.
               */
              constructor() {
                  _transferOwnership(_msgSender());
              }
              /**
               * @dev Throws if called by any account other than the owner.
               */
              modifier onlyOwner() {
                  _checkOwner();
                  _;
              }
              /**
               * @dev Returns the address of the current owner.
               */
              function owner() public view virtual returns (address) {
                  return _owner;
              }
              /**
               * @dev Throws if the sender is not the owner.
               */
              function _checkOwner() internal view virtual {
                  require(owner() == _msgSender(), "Ownable: caller is not the owner");
              }
              /**
               * @dev Leaves the contract without owner. It will not be possible to call
               * `onlyOwner` functions anymore. Can only be called by the current owner.
               *
               * NOTE: Renouncing ownership will leave the contract without an owner,
               * thereby removing any functionality that is only available to the owner.
               */
              function renounceOwnership() public virtual onlyOwner {
                  _transferOwnership(address(0));
              }
              /**
               * @dev Transfers ownership of the contract to a new account (`newOwner`).
               * Can only be called by the current owner.
               */
              function transferOwnership(address newOwner) public virtual onlyOwner {
                  require(newOwner != address(0), "Ownable: new owner is the zero address");
                  _transferOwnership(newOwner);
              }
              /**
               * @dev Transfers ownership of the contract to a new account (`newOwner`).
               * Internal function without access restriction.
               */
              function _transferOwnership(address newOwner) internal virtual {
                  address oldOwner = _owner;
                  _owner = newOwner;
                  emit OwnershipTransferred(oldOwner, newOwner);
              }
          }
          // SPDX-License-Identifier: MIT
          // OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
          pragma solidity ^0.8.0;
          /**
           * @dev Provides information about the current execution context, including the
           * sender of the transaction and its data. While these are generally available
           * via msg.sender and msg.data, they should not be accessed in such a direct
           * manner, since when dealing with meta-transactions the account sending and
           * paying for execution may not be the actual sender (as far as an application
           * is concerned).
           *
           * This contract is only required for intermediate, library-like contracts.
           */
          abstract contract Context {
              function _msgSender() internal view virtual returns (address) {
                  return msg.sender;
              }
              function _msgData() internal view virtual returns (bytes calldata) {
                  return msg.data;
              }
          }
          // SPDX-License-Identifier: MIT
          // OpenZeppelin Contracts (last updated v4.7.0) (utils/structs/EnumerableSet.sol)
          // This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.
          pragma solidity ^0.8.0;
          /**
           * @dev Library for managing
           * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
           * types.
           *
           * Sets have the following properties:
           *
           * - Elements are added, removed, and checked for existence in constant time
           * (O(1)).
           * - Elements are enumerated in O(n). No guarantees are made on the ordering.
           *
           * ```
           * contract Example {
           *     // Add the library methods
           *     using EnumerableSet for EnumerableSet.AddressSet;
           *
           *     // Declare a set state variable
           *     EnumerableSet.AddressSet private mySet;
           * }
           * ```
           *
           * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
           * and `uint256` (`UintSet`) are supported.
           *
           * [WARNING]
           * ====
           * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
           * unusable.
           * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
           *
           * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
           * array of EnumerableSet.
           * ====
           */
          library EnumerableSet {
              // To implement this library for multiple types with as little code
              // repetition as possible, we write it in terms of a generic Set type with
              // bytes32 values.
              // The Set implementation uses private functions, and user-facing
              // implementations (such as AddressSet) are just wrappers around the
              // underlying Set.
              // This means that we can only create new EnumerableSets for types that fit
              // in bytes32.
              struct Set {
                  // Storage of set values
                  bytes32[] _values;
                  // Position of the value in the `values` array, plus 1 because index 0
                  // means a value is not in the set.
                  mapping(bytes32 => uint256) _indexes;
              }
              /**
               * @dev Add a value to a set. O(1).
               *
               * Returns true if the value was added to the set, that is if it was not
               * already present.
               */
              function _add(Set storage set, bytes32 value) private returns (bool) {
                  if (!_contains(set, value)) {
                      set._values.push(value);
                      // The value is stored at length-1, but we add 1 to all indexes
                      // and use 0 as a sentinel value
                      set._indexes[value] = set._values.length;
                      return true;
                  } else {
                      return false;
                  }
              }
              /**
               * @dev Removes a value from a set. O(1).
               *
               * Returns true if the value was removed from the set, that is if it was
               * present.
               */
              function _remove(Set storage set, bytes32 value) private returns (bool) {
                  // We read and store the value's index to prevent multiple reads from the same storage slot
                  uint256 valueIndex = set._indexes[value];
                  if (valueIndex != 0) {
                      // Equivalent to contains(set, value)
                      // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
                      // the array, and then remove the last element (sometimes called as 'swap and pop').
                      // This modifies the order of the array, as noted in {at}.
                      uint256 toDeleteIndex = valueIndex - 1;
                      uint256 lastIndex = set._values.length - 1;
                      if (lastIndex != toDeleteIndex) {
                          bytes32 lastValue = set._values[lastIndex];
                          // Move the last value to the index where the value to delete is
                          set._values[toDeleteIndex] = lastValue;
                          // Update the index for the moved value
                          set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
                      }
                      // Delete the slot where the moved value was stored
                      set._values.pop();
                      // Delete the index for the deleted slot
                      delete set._indexes[value];
                      return true;
                  } else {
                      return false;
                  }
              }
              /**
               * @dev Returns true if the value is in the set. O(1).
               */
              function _contains(Set storage set, bytes32 value) private view returns (bool) {
                  return set._indexes[value] != 0;
              }
              /**
               * @dev Returns the number of values on the set. O(1).
               */
              function _length(Set storage set) private view returns (uint256) {
                  return set._values.length;
              }
              /**
               * @dev Returns the value stored at position `index` in the set. O(1).
               *
               * Note that there are no guarantees on the ordering of values inside the
               * array, and it may change when more values are added or removed.
               *
               * Requirements:
               *
               * - `index` must be strictly less than {length}.
               */
              function _at(Set storage set, uint256 index) private view returns (bytes32) {
                  return set._values[index];
              }
              /**
               * @dev Return the entire set in an array
               *
               * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
               * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
               * this function has an unbounded cost, and using it as part of a state-changing function may render the function
               * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
               */
              function _values(Set storage set) private view returns (bytes32[] memory) {
                  return set._values;
              }
              // Bytes32Set
              struct Bytes32Set {
                  Set _inner;
              }
              /**
               * @dev Add a value to a set. O(1).
               *
               * Returns true if the value was added to the set, that is if it was not
               * already present.
               */
              function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
                  return _add(set._inner, value);
              }
              /**
               * @dev Removes a value from a set. O(1).
               *
               * Returns true if the value was removed from the set, that is if it was
               * present.
               */
              function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
                  return _remove(set._inner, value);
              }
              /**
               * @dev Returns true if the value is in the set. O(1).
               */
              function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
                  return _contains(set._inner, value);
              }
              /**
               * @dev Returns the number of values in the set. O(1).
               */
              function length(Bytes32Set storage set) internal view returns (uint256) {
                  return _length(set._inner);
              }
              /**
               * @dev Returns the value stored at position `index` in the set. O(1).
               *
               * Note that there are no guarantees on the ordering of values inside the
               * array, and it may change when more values are added or removed.
               *
               * Requirements:
               *
               * - `index` must be strictly less than {length}.
               */
              function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
                  return _at(set._inner, index);
              }
              /**
               * @dev Return the entire set in an array
               *
               * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
               * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
               * this function has an unbounded cost, and using it as part of a state-changing function may render the function
               * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
               */
              function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
                  bytes32[] memory store = _values(set._inner);
                  bytes32[] memory result;
                  /// @solidity memory-safe-assembly
                  assembly {
                      result := store
                  }
                  return result;
              }
              // AddressSet
              struct AddressSet {
                  Set _inner;
              }
              /**
               * @dev Add a value to a set. O(1).
               *
               * Returns true if the value was added to the set, that is if it was not
               * already present.
               */
              function add(AddressSet storage set, address value) internal returns (bool) {
                  return _add(set._inner, bytes32(uint256(uint160(value))));
              }
              /**
               * @dev Removes a value from a set. O(1).
               *
               * Returns true if the value was removed from the set, that is if it was
               * present.
               */
              function remove(AddressSet storage set, address value) internal returns (bool) {
                  return _remove(set._inner, bytes32(uint256(uint160(value))));
              }
              /**
               * @dev Returns true if the value is in the set. O(1).
               */
              function contains(AddressSet storage set, address value) internal view returns (bool) {
                  return _contains(set._inner, bytes32(uint256(uint160(value))));
              }
              /**
               * @dev Returns the number of values in the set. O(1).
               */
              function length(AddressSet storage set) internal view returns (uint256) {
                  return _length(set._inner);
              }
              /**
               * @dev Returns the value stored at position `index` in the set. O(1).
               *
               * Note that there are no guarantees on the ordering of values inside the
               * array, and it may change when more values are added or removed.
               *
               * Requirements:
               *
               * - `index` must be strictly less than {length}.
               */
              function at(AddressSet storage set, uint256 index) internal view returns (address) {
                  return address(uint160(uint256(_at(set._inner, index))));
              }
              /**
               * @dev Return the entire set in an array
               *
               * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
               * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
               * this function has an unbounded cost, and using it as part of a state-changing function may render the function
               * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
               */
              function values(AddressSet storage set) internal view returns (address[] memory) {
                  bytes32[] memory store = _values(set._inner);
                  address[] memory result;
                  /// @solidity memory-safe-assembly
                  assembly {
                      result := store
                  }
                  return result;
              }
              // UintSet
              struct UintSet {
                  Set _inner;
              }
              /**
               * @dev Add a value to a set. O(1).
               *
               * Returns true if the value was added to the set, that is if it was not
               * already present.
               */
              function add(UintSet storage set, uint256 value) internal returns (bool) {
                  return _add(set._inner, bytes32(value));
              }
              /**
               * @dev Removes a value from a set. O(1).
               *
               * Returns true if the value was removed from the set, that is if it was
               * present.
               */
              function remove(UintSet storage set, uint256 value) internal returns (bool) {
                  return _remove(set._inner, bytes32(value));
              }
              /**
               * @dev Returns true if the value is in the set. O(1).
               */
              function contains(UintSet storage set, uint256 value) internal view returns (bool) {
                  return _contains(set._inner, bytes32(value));
              }
              /**
               * @dev Returns the number of values in the set. O(1).
               */
              function length(UintSet storage set) internal view returns (uint256) {
                  return _length(set._inner);
              }
              /**
               * @dev Returns the value stored at position `index` in the set. O(1).
               *
               * Note that there are no guarantees on the ordering of values inside the
               * array, and it may change when more values are added or removed.
               *
               * Requirements:
               *
               * - `index` must be strictly less than {length}.
               */
              function at(UintSet storage set, uint256 index) internal view returns (uint256) {
                  return uint256(_at(set._inner, index));
              }
              /**
               * @dev Return the entire set in an array
               *
               * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
               * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
               * this function has an unbounded cost, and using it as part of a state-changing function may render the function
               * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
               */
              function values(UintSet storage set) internal view returns (uint256[] memory) {
                  bytes32[] memory store = _values(set._inner);
                  uint256[] memory result;
                  /// @solidity memory-safe-assembly
                  assembly {
                      result := store
                  }
                  return result;
              }
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.13;
          import {EnumerableSet} from "openzeppelin-contracts/utils/structs/EnumerableSet.sol";
          interface IOperatorFilterRegistry {
              function isOperatorAllowed(address registrant, address operator) external returns (bool);
              function register(address registrant) external;
              function registerAndSubscribe(address registrant, address subscription) external;
              function registerAndCopyEntries(address registrant, address registrantToCopy) external;
              function updateOperator(address registrant, address operator, bool filtered) external;
              function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
              function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
              function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
              function subscribe(address registrant, address registrantToSubscribe) external;
              function unsubscribe(address registrant, bool copyExistingEntries) external;
              function subscriptionOf(address addr) external returns (address registrant);
              function subscribers(address registrant) external returns (address[] memory);
              function subscriberAt(address registrant, uint256 index) external returns (address);
              function copyEntriesOf(address registrant, address registrantToCopy) external;
              function isOperatorFiltered(address registrant, address operator) external returns (bool);
              function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
              function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
              function filteredOperators(address addr) external returns (address[] memory);
              function filteredCodeHashes(address addr) external returns (bytes32[] memory);
              function filteredOperatorAt(address registrant, uint256 index) external returns (address);
              function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
              function isRegistered(address addr) external returns (bool);
              function codeHashOf(address addr) external returns (bytes32);
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.13;
          import {IOperatorFilterRegistry} from "./IOperatorFilterRegistry.sol";
          import {Ownable} from "openzeppelin-contracts/access/Ownable.sol";
          import {EnumerableSet} from "openzeppelin-contracts/utils/structs/EnumerableSet.sol";
          import {OperatorFilterRegistryErrorsAndEvents} from "./OperatorFilterRegistryErrorsAndEvents.sol";
          /**
           * @title  OperatorFilterRegistry
           * @notice Borrows heavily from the QQL BlacklistOperatorFilter contract:
           *         https://github.com/qql-art/contracts/blob/main/contracts/BlacklistOperatorFilter.sol
           * @notice This contracts allows tokens or token owners to register specific addresses or codeHashes that may be
           * *       restricted according to the isOperatorAllowed function.
           */
          contract OperatorFilterRegistry is IOperatorFilterRegistry, OperatorFilterRegistryErrorsAndEvents {
              using EnumerableSet for EnumerableSet.AddressSet;
              using EnumerableSet for EnumerableSet.Bytes32Set;
              /// @dev initialized accounts have a nonzero codehash (see https://eips.ethereum.org/EIPS/eip-1052)
              /// Note that this will also be a smart contract's codehash when making calls from its constructor.
              bytes32 constant EOA_CODEHASH = keccak256("");
              mapping(address => EnumerableSet.AddressSet) private _filteredOperators;
              mapping(address => EnumerableSet.Bytes32Set) private _filteredCodeHashes;
              mapping(address => address) private _registrations;
              mapping(address => EnumerableSet.AddressSet) private _subscribers;
              /**
               * @notice restricts method caller to the address or EIP-173 "owner()"
               */
              modifier onlyAddressOrOwner(address addr) {
                  if (msg.sender != addr) {
                      try Ownable(addr).owner() returns (address owner) {
                          if (msg.sender != owner) {
                              revert OnlyAddressOrOwner();
                          }
                      } catch (bytes memory reason) {
                          if (reason.length == 0) {
                              revert NotOwnable();
                          } else {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  revert(add(32, reason), mload(reason))
                              }
                          }
                      }
                  }
                  _;
              }
              /**
               * @notice Returns true if operator is not filtered for a given token, either by address or codeHash. Also returns
               *         true if supplied registrant address is not registered.
               */
              function isOperatorAllowed(address registrant, address operator) external view returns (bool) {
                  address registration = _registrations[registrant];
                  if (registration != address(0)) {
                      EnumerableSet.AddressSet storage filteredOperatorsRef;
                      EnumerableSet.Bytes32Set storage filteredCodeHashesRef;
                      filteredOperatorsRef = _filteredOperators[registration];
                      filteredCodeHashesRef = _filteredCodeHashes[registration];
                      if (filteredOperatorsRef.contains(operator)) {
                          revert AddressFiltered(operator);
                      }
                      if (operator.code.length > 0) {
                          bytes32 codeHash = operator.codehash;
                          if (filteredCodeHashesRef.contains(codeHash)) {
                              revert CodeHashFiltered(operator, codeHash);
                          }
                      }
                  }
                  return true;
              }
              //////////////////
              // AUTH METHODS //
              //////////////////
              /**
               * @notice Registers an address with the registry. May be called by address itself or by EIP-173 owner.
               */
              function register(address registrant) external onlyAddressOrOwner(registrant) {
                  if (_registrations[registrant] != address(0)) {
                      revert AlreadyRegistered();
                  }
                  _registrations[registrant] = registrant;
                  emit RegistrationUpdated(registrant, true);
              }
              /**
               * @notice Unregisters an address with the registry and removes its subscription. May be called by address itself or by EIP-173 owner.
               *         Note that this does not remove any filtered addresses or codeHashes.
               *         Also note that any subscriptions to this registrant will still be active and follow the existing filtered addresses and codehashes.
               */
              function unregister(address registrant) external onlyAddressOrOwner(registrant) {
                  address registration = _registrations[registrant];
                  if (registration == address(0)) {
                      revert NotRegistered(registrant);
                  }
                  if (registration != registrant) {
                      _subscribers[registration].remove(registrant);
                      emit SubscriptionUpdated(registrant, registration, false);
                  }
                  _registrations[registrant] = address(0);
                  emit RegistrationUpdated(registrant, false);
              }
              /**
               * @notice Registers an address with the registry and "subscribes" to another address's filtered operators and codeHashes.
               */
              function registerAndSubscribe(address registrant, address subscription) external onlyAddressOrOwner(registrant) {
                  address registration = _registrations[registrant];
                  if (registration != address(0)) {
                      revert AlreadyRegistered();
                  }
                  if (registrant == subscription) {
                      revert CannotSubscribeToSelf();
                  }
                  address subscriptionRegistration = _registrations[subscription];
                  if (subscriptionRegistration == address(0)) {
                      revert NotRegistered(subscription);
                  }
                  if (subscriptionRegistration != subscription) {
                      revert CannotSubscribeToRegistrantWithSubscription(subscription);
                  }
                  _registrations[registrant] = subscription;
                  _subscribers[subscription].add(registrant);
                  emit RegistrationUpdated(registrant, true);
                  emit SubscriptionUpdated(registrant, subscription, true);
              }
              /**
               * @notice Registers an address with the registry and copies the filtered operators and codeHashes from another
               *         address without subscribing.
               */
              function registerAndCopyEntries(address registrant, address registrantToCopy)
                  external
                  onlyAddressOrOwner(registrant)
              {
                  if (registrantToCopy == registrant) {
                      revert CannotCopyFromSelf();
                  }
                  address registration = _registrations[registrant];
                  if (registration != address(0)) {
                      revert AlreadyRegistered();
                  }
                  address registrantRegistration = _registrations[registrantToCopy];
                  if (registrantRegistration == address(0)) {
                      revert NotRegistered(registrantToCopy);
                  }
                  _registrations[registrant] = registrant;
                  emit RegistrationUpdated(registrant, true);
                  _copyEntries(registrant, registrantToCopy);
              }
              /**
               * @notice Update an operator address for a registered address - when filtered is true, the operator is filtered.
               */
              function updateOperator(address registrant, address operator, bool filtered)
                  external
                  onlyAddressOrOwner(registrant)
              {
                  address registration = _registrations[registrant];
                  if (registration == address(0)) {
                      revert NotRegistered(registrant);
                  }
                  if (registration != registrant) {
                      revert CannotUpdateWhileSubscribed(registration);
                  }
                  EnumerableSet.AddressSet storage filteredOperatorsRef = _filteredOperators[registrant];
                  if (!filtered) {
                      bool removed = filteredOperatorsRef.remove(operator);
                      if (!removed) {
                          revert AddressNotFiltered(operator);
                      }
                  } else {
                      bool added = filteredOperatorsRef.add(operator);
                      if (!added) {
                          revert AddressAlreadyFiltered(operator);
                      }
                  }
                  emit OperatorUpdated(registrant, operator, filtered);
              }
              /**
               * @notice Update a codeHash for a registered address - when filtered is true, the codeHash is filtered.
               */
              function updateCodeHash(address registrant, bytes32 codeHash, bool filtered)
                  external
                  onlyAddressOrOwner(registrant)
              {
                  if (codeHash == EOA_CODEHASH) {
                      revert CannotFilterEOAs();
                  }
                  address registration = _registrations[registrant];
                  if (registration == address(0)) {
                      revert NotRegistered(registrant);
                  }
                  if (registration != registrant) {
                      revert CannotUpdateWhileSubscribed(registration);
                  }
                  EnumerableSet.Bytes32Set storage filteredCodeHashesRef = _filteredCodeHashes[registrant];
                  if (!filtered) {
                      bool removed = filteredCodeHashesRef.remove(codeHash);
                      if (!removed) {
                          revert CodeHashNotFiltered(codeHash);
                      }
                  } else {
                      bool added = filteredCodeHashesRef.add(codeHash);
                      if (!added) {
                          revert CodeHashAlreadyFiltered(codeHash);
                      }
                  }
                  emit CodeHashUpdated(registrant, codeHash, filtered);
              }
              /**
               * @notice Update multiple operators for a registered address - when filtered is true, the operators will be filtered. Reverts on duplicates.
               */
              function updateOperators(address registrant, address[] calldata operators, bool filtered)
                  external
                  onlyAddressOrOwner(registrant)
              {
                  address registration = _registrations[registrant];
                  if (registration == address(0)) {
                      revert NotRegistered(registrant);
                  }
                  if (registration != registrant) {
                      revert CannotUpdateWhileSubscribed(registration);
                  }
                  EnumerableSet.AddressSet storage filteredOperatorsRef = _filteredOperators[registrant];
                  uint256 operatorsLength = operators.length;
                  unchecked {
                      if (!filtered) {
                          for (uint256 i = 0; i < operatorsLength; ++i) {
                              address operator = operators[i];
                              bool removed = filteredOperatorsRef.remove(operator);
                              if (!removed) {
                                  revert AddressNotFiltered(operator);
                              }
                          }
                      } else {
                          for (uint256 i = 0; i < operatorsLength; ++i) {
                              address operator = operators[i];
                              bool added = filteredOperatorsRef.add(operator);
                              if (!added) {
                                  revert AddressAlreadyFiltered(operator);
                              }
                          }
                      }
                  }
                  emit OperatorsUpdated(registrant, operators, filtered);
              }
              /**
               * @notice Update multiple codeHashes for a registered address - when filtered is true, the codeHashes will be filtered. Reverts on duplicates.
               */
              function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered)
                  external
                  onlyAddressOrOwner(registrant)
              {
                  address registration = _registrations[registrant];
                  if (registration == address(0)) {
                      revert NotRegistered(registrant);
                  }
                  if (registration != registrant) {
                      revert CannotUpdateWhileSubscribed(registration);
                  }
                  EnumerableSet.Bytes32Set storage filteredCodeHashesRef = _filteredCodeHashes[registrant];
                  uint256 codeHashesLength = codeHashes.length;
                  unchecked {
                      if (!filtered) {
                          for (uint256 i = 0; i < codeHashesLength; ++i) {
                              bytes32 codeHash = codeHashes[i];
                              bool removed = filteredCodeHashesRef.remove(codeHash);
                              if (!removed) {
                                  revert CodeHashNotFiltered(codeHash);
                              }
                          }
                      } else {
                          for (uint256 i = 0; i < codeHashesLength; ++i) {
                              bytes32 codeHash = codeHashes[i];
                              if (codeHash == EOA_CODEHASH) {
                                  revert CannotFilterEOAs();
                              }
                              bool added = filteredCodeHashesRef.add(codeHash);
                              if (!added) {
                                  revert CodeHashAlreadyFiltered(codeHash);
                              }
                          }
                      }
                  }
                  emit CodeHashesUpdated(registrant, codeHashes, filtered);
              }
              /**
               * @notice Subscribe an address to another registrant's filtered operators and codeHashes. Will remove previous
               *         subscription if present.
               *         Note that accounts with subscriptions may go on to subscribe to other accounts - in this case,
               *         subscriptions will not be forwarded. Instead the former subscription's existing entries will still be
               *         used.
               */
              function subscribe(address registrant, address newSubscription) external onlyAddressOrOwner(registrant) {
                  if (registrant == newSubscription) {
                      revert CannotSubscribeToSelf();
                  }
                  if (newSubscription == address(0)) {
                      revert CannotSubscribeToZeroAddress();
                  }
                  address registration = _registrations[registrant];
                  if (registration == address(0)) {
                      revert NotRegistered(registrant);
                  }
                  if (registration == newSubscription) {
                      revert AlreadySubscribed(newSubscription);
                  }
                  address newSubscriptionRegistration = _registrations[newSubscription];
                  if (newSubscriptionRegistration == address(0)) {
                      revert NotRegistered(newSubscription);
                  }
                  if (newSubscriptionRegistration != newSubscription) {
                      revert CannotSubscribeToRegistrantWithSubscription(newSubscription);
                  }
                  if (registration != registrant) {
                      _subscribers[registration].remove(registrant);
                      emit SubscriptionUpdated(registrant, registration, false);
                  }
                  _registrations[registrant] = newSubscription;
                  _subscribers[newSubscription].add(registrant);
                  emit SubscriptionUpdated(registrant, newSubscription, true);
              }
              /**
               * @notice Unsubscribe an address from its current subscribed registrant, and optionally copy its filtered operators and codeHashes.
               */
              function unsubscribe(address registrant, bool copyExistingEntries) external onlyAddressOrOwner(registrant) {
                  address registration = _registrations[registrant];
                  if (registration == address(0)) {
                      revert NotRegistered(registrant);
                  }
                  if (registration == registrant) {
                      revert NotSubscribed();
                  }
                  _subscribers[registration].remove(registrant);
                  _registrations[registrant] = registrant;
                  emit SubscriptionUpdated(registrant, registration, false);
                  if (copyExistingEntries) {
                      _copyEntries(registrant, registration);
                  }
              }
              /**
               * @notice Copy filtered operators and codeHashes from a different registrantToCopy to addr.
               */
              function copyEntriesOf(address registrant, address registrantToCopy) external onlyAddressOrOwner(registrant) {
                  if (registrant == registrantToCopy) {
                      revert CannotCopyFromSelf();
                  }
                  address registration = _registrations[registrant];
                  if (registration == address(0)) {
                      revert NotRegistered(registrant);
                  }
                  if (registration != registrant) {
                      revert CannotUpdateWhileSubscribed(registration);
                  }
                  address registrantRegistration = _registrations[registrantToCopy];
                  if (registrantRegistration == address(0)) {
                      revert NotRegistered(registrantToCopy);
                  }
                  _copyEntries(registrant, registrantToCopy);
              }
              /// @dev helper to copy entries from registrantToCopy to registrant and emit events
              function _copyEntries(address registrant, address registrantToCopy) private {
                  EnumerableSet.AddressSet storage filteredOperatorsRef = _filteredOperators[registrantToCopy];
                  EnumerableSet.Bytes32Set storage filteredCodeHashesRef = _filteredCodeHashes[registrantToCopy];
                  uint256 filteredOperatorsLength = filteredOperatorsRef.length();
                  uint256 filteredCodeHashesLength = filteredCodeHashesRef.length();
                  unchecked {
                      for (uint256 i = 0; i < filteredOperatorsLength; ++i) {
                          address operator = filteredOperatorsRef.at(i);
                          bool added = _filteredOperators[registrant].add(operator);
                          if (added) {
                              emit OperatorUpdated(registrant, operator, true);
                          }
                      }
                      for (uint256 i = 0; i < filteredCodeHashesLength; ++i) {
                          bytes32 codehash = filteredCodeHashesRef.at(i);
                          bool added = _filteredCodeHashes[registrant].add(codehash);
                          if (added) {
                              emit CodeHashUpdated(registrant, codehash, true);
                          }
                      }
                  }
              }
              //////////////////
              // VIEW METHODS //
              //////////////////
              /**
               * @notice Get the subscription address of a given registrant, if any.
               */
              function subscriptionOf(address registrant) external view returns (address subscription) {
                  subscription = _registrations[registrant];
                  if (subscription == address(0)) {
                      revert NotRegistered(registrant);
                  } else if (subscription == registrant) {
                      subscription = address(0);
                  }
              }
              /**
               * @notice Get the set of addresses subscribed to a given registrant.
               *         Note that order is not guaranteed as updates are made.
               */
              function subscribers(address registrant) external view returns (address[] memory) {
                  return _subscribers[registrant].values();
              }
              /**
               * @notice Get the subscriber at a given index in the set of addresses subscribed to a given registrant.
               *         Note that order is not guaranteed as updates are made.
               */
              function subscriberAt(address registrant, uint256 index) external view returns (address) {
                  return _subscribers[registrant].at(index);
              }
              /**
               * @notice Returns true if operator is filtered by a given address or its subscription.
               */
              function isOperatorFiltered(address registrant, address operator) external view returns (bool) {
                  address registration = _registrations[registrant];
                  if (registration != registrant) {
                      return _filteredOperators[registration].contains(operator);
                  }
                  return _filteredOperators[registrant].contains(operator);
              }
              /**
               * @notice Returns true if a codeHash is filtered by a given address or its subscription.
               */
              function isCodeHashFiltered(address registrant, bytes32 codeHash) external view returns (bool) {
                  address registration = _registrations[registrant];
                  if (registration != registrant) {
                      return _filteredCodeHashes[registration].contains(codeHash);
                  }
                  return _filteredCodeHashes[registrant].contains(codeHash);
              }
              /**
               * @notice Returns true if the hash of an address's code is filtered by a given address or its subscription.
               */
              function isCodeHashOfFiltered(address registrant, address operatorWithCode) external view returns (bool) {
                  bytes32 codeHash = operatorWithCode.codehash;
                  address registration = _registrations[registrant];
                  if (registration != registrant) {
                      return _filteredCodeHashes[registration].contains(codeHash);
                  }
                  return _filteredCodeHashes[registrant].contains(codeHash);
              }
              /**
               * @notice Returns true if an address has registered
               */
              function isRegistered(address registrant) external view returns (bool) {
                  return _registrations[registrant] != address(0);
              }
              /**
               * @notice Returns a list of filtered operators for a given address or its subscription.
               */
              function filteredOperators(address registrant) external view returns (address[] memory) {
                  address registration = _registrations[registrant];
                  if (registration != registrant) {
                      return _filteredOperators[registration].values();
                  }
                  return _filteredOperators[registrant].values();
              }
              /**
               * @notice Returns the set of filtered codeHashes for a given address or its subscription.
               *         Note that order is not guaranteed as updates are made.
               */
              function filteredCodeHashes(address registrant) external view returns (bytes32[] memory) {
                  address registration = _registrations[registrant];
                  if (registration != registrant) {
                      return _filteredCodeHashes[registration].values();
                  }
                  return _filteredCodeHashes[registrant].values();
              }
              /**
               * @notice Returns the filtered operator at the given index of the set of filtered operators for a given address or
               *         its subscription.
               *         Note that order is not guaranteed as updates are made.
               */
              function filteredOperatorAt(address registrant, uint256 index) external view returns (address) {
                  address registration = _registrations[registrant];
                  if (registration != registrant) {
                      return _filteredOperators[registration].at(index);
                  }
                  return _filteredOperators[registrant].at(index);
              }
              /**
               * @notice Returns the filtered codeHash at the given index of the list of filtered codeHashes for a given address or
               *         its subscription.
               *         Note that order is not guaranteed as updates are made.
               */
              function filteredCodeHashAt(address registrant, uint256 index) external view returns (bytes32) {
                  address registration = _registrations[registrant];
                  if (registration != registrant) {
                      return _filteredCodeHashes[registration].at(index);
                  }
                  return _filteredCodeHashes[registrant].at(index);
              }
              /// @dev Convenience method to compute the code hash of an arbitrary contract
              function codeHashOf(address a) external view returns (bytes32) {
                  return a.codehash;
              }
          }
          // SPDX-License-Identifier: MIT
          pragma solidity ^0.8.13;
          contract OperatorFilterRegistryErrorsAndEvents {
              error CannotFilterEOAs();
              error AddressAlreadyFiltered(address operator);
              error AddressNotFiltered(address operator);
              error CodeHashAlreadyFiltered(bytes32 codeHash);
              error CodeHashNotFiltered(bytes32 codeHash);
              error OnlyAddressOrOwner();
              error NotRegistered(address registrant);
              error AlreadyRegistered();
              error AlreadySubscribed(address subscription);
              error NotSubscribed();
              error CannotUpdateWhileSubscribed(address subscription);
              error CannotSubscribeToSelf();
              error CannotSubscribeToZeroAddress();
              error NotOwnable();
              error AddressFiltered(address filtered);
              error CodeHashFiltered(address account, bytes32 codeHash);
              error CannotSubscribeToRegistrantWithSubscription(address registrant);
              error CannotCopyFromSelf();
              event RegistrationUpdated(address indexed registrant, bool indexed registered);
              event OperatorUpdated(address indexed registrant, address indexed operator, bool indexed filtered);
              event OperatorsUpdated(address indexed registrant, address[] operators, bool indexed filtered);
              event CodeHashUpdated(address indexed registrant, bytes32 indexed codeHash, bool indexed filtered);
              event CodeHashesUpdated(address indexed registrant, bytes32[] codeHashes, bool indexed filtered);
              event SubscriptionUpdated(address indexed registrant, address indexed subscription, bool indexed subscribed);
          }