ETH Price: $2,526.62 (-0.44%)

Transaction Decoder

Block:
21161359 at Nov-11-2024 02:09:35 AM +UTC
Transaction Fee:
0.003297396745656929 ETH $8.33
Gas Used:
214,243 Gas / 15.390919403 Gwei

Emitted Events:

160 ERC1967Proxy.0x2469cc9e12e74c63438d5b1117b318cd3a4cdaf9d659d9eac6d975d14d963254( 0x2469cc9e12e74c63438d5b1117b318cd3a4cdaf9d659d9eac6d975d14d963254, 0000000000000000000000000000000000000000000000000000000000047d9c, 0000000000000000000000003af2a97414d1101e2107a70e7f33955da1346305 )
161 MysteryBean.Approval( owner=[Receiver] ERC1967Proxy, approved=Delegate, tokenId=6373 )
162 MysteryBean.Transfer( from=[Receiver] ERC1967Proxy, to=0xf9d6445c...8d7BBc573, tokenId=6373 )
163 ERC1967Proxy.0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef( 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x000000000000000000000000f9d6445c80b67dc62d5b1178500b9898d7bbc573, 0x00000000000000000000000029469395eaf6f95920e59f858042f0e28d98a20b, 0000000000000000000000000000000000000000000000000b84c09a3b930000 )
164 ERC1967Proxy.0x1d5e12b51dee5e4d34434576c3fb99714a85f57b0fd546ada4b0bddd736d12b2( 0x1d5e12b51dee5e4d34434576c3fb99714a85f57b0fd546ada4b0bddd736d12b2, 6e76f36d21204dfd74586b3db614507e3388bf55149aa2509521fe4c2a05ead0, 00000000000000000018e500f9d6445c80b67dc62d5b1178500b9898d7bbc573, 010000000b84c09a3b9300003af2a97414d1101e2107a70e7f33955da1346305 )
165 ERC1967Proxy.0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef( 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00000000000000000000000029469395eaf6f95920e59f858042f0e28d98a20b, 0x0000000000000000000000008bc110db7029197c3621bea8092ab1996d5dd7be, 0000000000000000000000000000000000000000000000000418f30285e7adfa )
166 ERC1967Proxy.0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef( 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00000000000000000000000029469395eaf6f95920e59f858042f0e28d98a20b, 0x000000000000000000000000f64932b6002fd2a465a72564d80422f762aaa566, 000000000000000000000000000000000000000000000000076bcd97b5ab5206 )

Account State Difference:

  Address   Before After State Difference Code
0x00000000...d351887Ac
0x29469395...28D98a20B
(Blur: Blend)
0x3Af2A974...da1346305
(Titan Builder)
9.108568960747697146 Eth9.108960028350775146 Eth0.000391067603078
0xb2ecfE4E...e2410CEA5
(Blur.io: Marketplace 3)
0xf64932b6...762aaA566
0.581928311700477665 Eth
Nonce: 2605
0.578630914954820736 Eth
Nonce: 2606
0.003297396745656929

Execution Trace

ERC1967Proxy.619a309f( )
  • Blend.takeBidV2( )
    • Helpers.computeCurrentDebt( amount=290000000000000000, rate=860, startTime=1724708171 ) => ( 295252967754804730 )
    • Helpers.e7fbdddb( )
      • ERC1967Proxy.70a08231( )
        • BlurPool.balanceOf( user=0x29469395eAf6f95920E59F858042f0e28D98a20B ) => ( 0 )
        • MysteryBean.approve( operator=0x2f18F339620a63e43f0839Eeb18D7de1e1Be4DfB, tokenId=6373 )
          • OperatorFilterRegistry.isOperatorAllowed( registrant=0x3Af2A97414d1101E2107a70E7F33955da1346305, operator=0x2f18F339620a63e43f0839Eeb18D7de1e1Be4DfB ) => ( True )
          • ERC1967Proxy.da815cb5( )
            • BlurExchangeV2.takeBidSingle( )
              • Null: 0x000...001.b1e1d034( )
              • Null: 0x000...001.039507eb( )
              • Delegate.transfer( taker=0x29469395eAf6f95920E59F858042f0e28D98a20B, orderType=1, transfers=, length=1 ) => ( successful=[true] )
                • MysteryBean.safeTransferFrom( from=0x29469395eAf6f95920E59F858042f0e28D98a20B, to=0xf9d6445c80b67Dc62D5B1178500b9898d7BBc573, tokenId=6373 )
                • ERC1967Proxy.23b872dd( )
                  • BlurPool.transferFrom( from=0xf9d6445c80b67Dc62D5B1178500b9898d7BBc573, to=0x29469395eAf6f95920E59F858042f0e28D98a20B, amount=830000000000000000 ) => ( True )
                  • ERC1967Proxy.70a08231( )
                    • BlurPool.balanceOf( user=0x29469395eAf6f95920E59F858042f0e28D98a20B ) => ( 830000000000000000 )
                    • ERC1967Proxy.23b872dd( )
                      • BlurPool.transferFrom( from=0x29469395eAf6f95920E59F858042f0e28D98a20B, to=0x8BC110Db7029197C3621bEA8092aB1996D5DD7BE, amount=295252967754804730 ) => ( True )
                      • ERC1967Proxy.23b872dd( )
                        • BlurPool.transferFrom( from=0x29469395eAf6f95920E59F858042f0e28D98a20B, to=0xf64932b6002FD2a465A72564D80422f762aaA566, amount=534747032245195270 ) => ( True )
                          File 1 of 10: ERC1967Proxy
                          // SPDX-License-Identifier: MIT
                          // OpenZeppelin Contracts v4.4.1 (proxy/ERC1967/ERC1967Proxy.sol)
                          pragma solidity 0.8.17;
                          import "lib/openzeppelin-contracts/contracts/proxy/Proxy.sol";
                          import "lib/openzeppelin-contracts/contracts/proxy/ERC1967/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
                          // OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)
                          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 internal call site, it will return directly to the external caller.
                               */
                              function _delegate(address implementation) internal virtual {
                                  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 overridden 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 internal 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 overridden should call `super._beforeFallback()`.
                               */
                              function _beforeFallback() internal virtual {}
                          }
                          // SPDX-License-Identifier: MIT
                          // OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)
                          pragma solidity ^0.8.2;
                          import "../beacon/IBeacon.sol";
                          import "../../interfaces/draft-IERC1822.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._
                           */
                          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 {
                                  _upgradeTo(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 _upgradeToAndCallUUPS(address newImplementation, bytes memory data, bool forceCall) internal {
                                  // Upgrades from old implementations will perform a rollback test. This test requires the new
                                  // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
                                  // this special case will break upgrade paths from old UUPS implementation to new ones.
                                  if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {
                                      _setImplementation(newImplementation);
                                  } else {
                                      try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
                                          require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
                                      } catch {
                                          revert("ERC1967Upgrade: new implementation is not UUPS");
                                      }
                                      _upgradeToAndCall(newImplementation, data, forceCall);
                                  }
                              }
                              /**
                               * @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;
                              }
                              /**
                               * @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);
                                  }
                              }
                          }
                          // SPDX-License-Identifier: MIT
                          // OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)
                          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
                          // OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)
                          pragma solidity ^0.8.0;
                          /**
                           * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
                           * proxy whose upgrades are fully controlled by the current implementation.
                           */
                          interface IERC1822Proxiable {
                              /**
                               * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
                               * address.
                               *
                               * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
                               * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
                               * function revert if invoked through a proxy.
                               */
                              function proxiableUUID() external view returns (bytes32);
                          }
                          // 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 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
                               *
                               * Furthermore, `isContract` will also return true if the target contract within
                               * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
                               * which only has an effect at the end of a transaction.
                               * ====
                               *
                               * [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://consensys.net/diligence/blog/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 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) {
                                  (bool success, bytes memory returndata) = target.delegatecall(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 (last updated v4.7.0) (utils/StorageSlot.sol)
                          // This file was procedurally generated from scripts/generate/templates/StorageSlot.js.
                          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:
                           * ```solidity
                           * 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`, `uint256`._
                           * _Available since v4.9 for `string`, `bytes`._
                           */
                          library StorageSlot {
                              struct AddressSlot {
                                  address value;
                              }
                              struct BooleanSlot {
                                  bool value;
                              }
                              struct Bytes32Slot {
                                  bytes32 value;
                              }
                              struct Uint256Slot {
                                  uint256 value;
                              }
                              struct StringSlot {
                                  string value;
                              }
                              struct BytesSlot {
                                  bytes value;
                              }
                              /**
                               * @dev Returns an `AddressSlot` with member `value` located at `slot`.
                               */
                              function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r.slot := slot
                                  }
                              }
                              /**
                               * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
                               */
                              function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r.slot := slot
                                  }
                              }
                              /**
                               * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
                               */
                              function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r.slot := slot
                                  }
                              }
                              /**
                               * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
                               */
                              function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r.slot := slot
                                  }
                              }
                              /**
                               * @dev Returns an `StringSlot` with member `value` located at `slot`.
                               */
                              function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r.slot := slot
                                  }
                              }
                              /**
                               * @dev Returns an `StringSlot` representation of the string storage pointer `store`.
                               */
                              function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r.slot := store.slot
                                  }
                              }
                              /**
                               * @dev Returns an `BytesSlot` with member `value` located at `slot`.
                               */
                              function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r.slot := slot
                                  }
                              }
                              /**
                               * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
                               */
                              function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r.slot := store.slot
                                  }
                              }
                          }
                          

                          File 2 of 10: MysteryBean
                          // SPDX-License-Identifier: MIT
                          pragma solidity ^0.8.18;
                          import "erc721a/contracts/ERC721A.sol";
                          import "@openzeppelin/contracts/token/common/ERC2981.sol";
                          import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
                          import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
                          import {BitMaps} from "@openzeppelin/contracts/utils/structs/BitMaps.sol";
                          import "closedsea/OperatorFilterer.sol";
                          import "./MultisigOwnable.sol";
                          error InvalidPresaleSetup();
                          error InvalidAuctionSetup();
                          error ChunkAlreadyProcessed();
                          error MismatchedArrays();
                          error AuctionMintNotOpen();
                          error MaxPresaleOrAuctionMintSupplyReached();
                          error RedeemBeanNotOpen();
                          error BeanRedeemerNotSet();
                          error ForceRedeemBeanOwnerMismatch();
                          error RegistryNotSet();
                          error NotAllowedByRegistry();
                          error WithdrawFailed();
                          error ClaimWindowNotOpen();
                          error MismatchedTokenOwnerForClaim();
                          error BeanCannotBeClaimed();
                          error InitialTransferLockOn();
                          error MaxAuctionMintForAddress();
                          error InsufficientFunds();
                          error RefundFailed();
                          error InvalidSignature();
                          error OverMaxSupply();
                          error AllowlistMintNotOpen();
                          error PresaleNotOpen();
                          error MintingTooMuchInPresale();
                          error InvalidContractSetup();
                          interface IBeanRedeemer {
                              function redeemBeans(address to, uint256[] calldata beanIds)
                                  external
                                  returns (uint256[] memory);
                          }
                          interface IRegistry {
                              function isAllowedOperator(address operator) external view returns (bool);
                          }
                          interface Azuki {
                              function ownerOf(uint256 tokenId) external view returns (address owner);
                          }
                          contract MysteryBean is ERC2981, MultisigOwnable, OperatorFilterer, ERC721A {
                              using ECDSA for bytes32;
                              using EnumerableSet for EnumerableSet.UintSet;
                              using BitMaps for BitMaps.BitMap;
                              event AirdroppedChunk(uint256 indexed chunkNum);
                              event ClaimedBean(uint256 indexed sourceAzukiId, uint256 indexed beanId);
                              event PresaleMint(address indexed minter, uint16 indexed amount);
                              // The set of chunks processed for the airdrop.
                              // Intent is to help prevent double processing of chunks.
                              EnumerableSet.UintSet private _processedChunksForAirdrop;
                              bool public operatorFilteringEnabled = true;
                              bool public initialTransferLockOn = true;
                              bool public isRegistryActive = false;
                              address public registryAddress;
                              bool public claimBeanOpen = false;
                              // Keys are azuki token ids
                              BitMaps.BitMap private _azukiCanClaim;
                              uint256 public immutable TOTAL_PRESALE_AND_AUCTION_SUPPLY;
                              uint16 public totalPresaleAndAuctionMinted;
                              struct PresaleInfo {
                                  uint32 presaleStartTime;
                                  uint32 presaleEndTime;
                                  uint64 presalePrice;
                              }
                              PresaleInfo public presaleInfo;
                              mapping(address => uint256) public numMintedInPresale;
                              struct AuctionInfo {
                                  uint32 auctionSaleStartTime;
                                  uint64 auctionStartPrice;
                                  uint64 auctionEndPrice;
                                  uint32 auctionPriceCurveLength;
                                  uint32 auctionDropInterval;
                              }
                              AuctionInfo public auctionInfo;
                              address private _offchainSigner;
                              struct RedeemInfo {
                                  bool redeemBeanOpen;
                                  address beanRedeemer;
                              }
                              RedeemInfo public redeemInfo;
                              mapping(address => uint256) public allowlistMintsAlloc;
                              uint256 public allowlistMintPrice;
                              uint256 public immutable MAX_SUPPLY;
                              string private _baseTokenURI;
                              Azuki public immutable AZUKI;
                              address payable public immutable WITHDRAW_ADDRESS;
                              uint256 public constant MINT_BATCH_SIZE = 10;
                              constructor(
                                  address _azukiAddress,
                                  uint256 _maxSupply,
                                  uint256 _totalPresaleAndAuctionSupply,
                                  address payable _withdrawAddress
                              ) ERC721A("MysteryBean", "MBEAN") {
                                  AZUKI = Azuki(_azukiAddress);
                                  MAX_SUPPLY = _maxSupply;
                                  TOTAL_PRESALE_AND_AUCTION_SUPPLY = _totalPresaleAndAuctionSupply;
                                  WITHDRAW_ADDRESS = _withdrawAddress;
                                  if (TOTAL_PRESALE_AND_AUCTION_SUPPLY >= MAX_SUPPLY)
                                      revert InvalidContractSetup();
                                  _registerForOperatorFiltering();
                                  operatorFilteringEnabled = true;
                              }
                              // ---------------------------
                              // Airdrop and privileged mint
                              // ---------------------------
                              // Thin wrapper around privilegedMint which does chunkNum checks to reduce chance of double processing chunks in a manual airdrop.
                              function airdrop(
                                  address[] calldata receivers,
                                  uint256[] calldata amounts,
                                  uint256 chunkNum
                              ) external onlyOwner {
                                  if (_processedChunksForAirdrop.contains(chunkNum))
                                      revert ChunkAlreadyProcessed();
                                  _processedChunksForAirdrop.add(chunkNum);
                                  privilegedMint(receivers, amounts);
                                  emit AirdroppedChunk(chunkNum);
                              }
                              // Used for airdrop and minting any of the total supply that's unminted.
                              // Does not use safeMint (assumes the caller has checked whether contract receivers can receive 721s)
                              function privilegedMint(
                                  address[] calldata receivers,
                                  uint256[] calldata amounts
                              ) public onlyOwner {
                                  if (receivers.length != amounts.length || receivers.length == 0)
                                      revert MismatchedArrays();
                                  for (uint256 i; i < receivers.length; ) {
                                      _mintWrapperNoSafeReceiverCheck(receivers[i], amounts[i]);
                                      unchecked {
                                          ++i;
                                      }
                                  }
                                  if (_totalMinted() > MAX_SUPPLY) {
                                      revert OverMaxSupply();
                                  }
                              }
                              function _mintWrapperSafeReceiverCheck(address to, uint256 amount) private {
                                  uint256 numBatches = amount / MINT_BATCH_SIZE;
                                  for (uint256 i; i < numBatches; ) {
                                      _safeMint(to, MINT_BATCH_SIZE, "");
                                      unchecked {
                                          ++i;
                                      }
                                  }
                                  if (amount % MINT_BATCH_SIZE > 0) {
                                      _safeMint(to, amount % MINT_BATCH_SIZE, "");
                                  }
                              }
                              function _mintWrapperNoSafeReceiverCheck(address to, uint256 amount)
                                  private
                              {
                                  uint256 numBatches = amount / MINT_BATCH_SIZE;
                                  for (uint256 i; i < numBatches; ) {
                                      _mint(to, MINT_BATCH_SIZE);
                                      unchecked {
                                          ++i;
                                      }
                                  }
                                  if (amount % MINT_BATCH_SIZE > 0) {
                                      _mint(to, amount % MINT_BATCH_SIZE);
                                  }
                              }
                              // ----------------------------------------------
                              // Claim Window
                              // ----------------------------------------------
                              function claim(uint256[] calldata azukiTokenIds) external {
                                  if (!claimBeanOpen) {
                                      revert ClaimWindowNotOpen();
                                  }
                                  uint256 numToClaim = azukiTokenIds.length;
                                  if (_totalMinted() + numToClaim > MAX_SUPPLY) {
                                      revert OverMaxSupply();
                                  }
                                  uint256 nextTokenId = _nextTokenId();
                                  for (uint256 i; i < numToClaim; ) {
                                      uint256 azukiId = azukiTokenIds[i];
                                      if (AZUKI.ownerOf(azukiId) != msg.sender)
                                          revert MismatchedTokenOwnerForClaim();
                                      if (!_azukiCanClaim.get(azukiId)) revert BeanCannotBeClaimed();
                                      _azukiCanClaim.unset(azukiId);
                                      emit ClaimedBean(azukiId, nextTokenId + i);
                                      unchecked {
                                          ++i;
                                      }
                                  }
                                  _mintWrapperSafeReceiverCheck(msg.sender, numToClaim);
                              }
                              function setClaimBeanState(bool _claimBeanOpen) external onlyOwner {
                                  claimBeanOpen = _claimBeanOpen;
                              }
                              function setCanClaim(uint256[] calldata azukiIds) external onlyOwner {
                                  for (uint256 i; i < azukiIds.length; ) {
                                      _azukiCanClaim.set(azukiIds[i]);
                                      unchecked {
                                          ++i;
                                      }
                                  }
                              }
                              function getCanClaims(uint256[] calldata azukiIds)
                                  external
                                  view
                                  returns (bool[] memory)
                              {
                                  bool[] memory result = new bool[](azukiIds.length);
                                  for (uint256 i; i < azukiIds.length; ) {
                                      result[i] = _azukiCanClaim.get(azukiIds[i]);
                                      unchecked {
                                          ++i;
                                      }
                                  }
                                  return result;
                              }
                              // ------------
                              // Presale mint
                              // ------------
                              // maxAllowedForPresaleForAddr: the number the holder is allowed to mint during the entirety of the presale.
                              // Its value is verified through the signature. We do this instead of seeding the contract with state to avoid a more complex contract setup.
                              function presaleMint(
                                  uint16 amount,
                                  uint16 maxAllowedForPresaleForAddr,
                                  bytes calldata _signature
                              ) external payable {
                                  PresaleInfo memory info = presaleInfo;
                                  if (
                                      info.presaleStartTime == 0 ||
                                      block.timestamp < info.presaleStartTime ||
                                      block.timestamp >= info.presaleEndTime
                                  ) {
                                      revert PresaleNotOpen();
                                  }
                                  uint256 numMintedInPresaleLoc = numMintedInPresale[msg.sender];
                                  if (amount > maxAllowedForPresaleForAddr - numMintedInPresaleLoc) {
                                      revert MintingTooMuchInPresale();
                                  }
                                  uint16 totalPresaleAndAuctionMintedLocal = totalPresaleAndAuctionMinted;
                                  if (
                                      amount + totalPresaleAndAuctionMintedLocal >
                                      TOTAL_PRESALE_AND_AUCTION_SUPPLY
                                  ) {
                                      revert MaxPresaleOrAuctionMintSupplyReached();
                                  }
                                  if (_totalMinted() + amount > MAX_SUPPLY) {
                                      revert OverMaxSupply();
                                  }
                                  if (!_verifyPresaleSig(amount, maxAllowedForPresaleForAddr, _signature))
                                      revert InvalidSignature();
                                  uint256 totalCost = uint256(info.presalePrice) * amount;
                                  if (msg.value < totalCost) {
                                      revert InsufficientFunds();
                                  }
                                  unchecked {
                                      numMintedInPresale[msg.sender] = amount + numMintedInPresaleLoc;
                                      totalPresaleAndAuctionMinted =
                                          totalPresaleAndAuctionMintedLocal +
                                          amount;
                                  }
                                  _mintWrapperNoSafeReceiverCheck(msg.sender, amount);
                                  emit PresaleMint(msg.sender, amount);
                              }
                              function _verifyPresaleSig(
                                  uint16 amount,
                                  uint16 maxAllowedForPresaleForAddr,
                                  bytes memory _signature
                              ) private view returns (bool) {
                                  bytes32 hashVal = keccak256(
                                      abi.encodePacked(amount, msg.sender, maxAllowedForPresaleForAddr)
                                  );
                                  bytes32 signedHash = hashVal.toEthSignedMessageHash();
                                  address signingAddress = signedHash.recover(_signature);
                                  return signingAddress == _offchainSigner;
                              }
                              // Presale price to match starting price of dutch auction
                              function setPresaleParams(
                                  uint32 _presaleStartTime,
                                  uint32 _presaleEndTime,
                                  uint64 _presalePrice
                              ) external onlyOwner {
                                  if (
                                      _presaleStartTime == 0 || _presaleEndTime == 0 || _presalePrice == 0
                                  ) {
                                      revert InvalidPresaleSetup();
                                  }
                                  if (_presaleStartTime >= _presaleEndTime) {
                                      revert InvalidPresaleSetup();
                                  }
                                  presaleInfo = PresaleInfo(
                                      _presaleStartTime,
                                      _presaleEndTime,
                                      _presalePrice
                                  );
                              }
                              function setOffchainSigner(address _signer) external onlyOwner {
                                  _offchainSigner = _signer;
                              }
                              // -------------
                              // Dutch auction
                              // -------------
                              uint256 public constant MAX_PER_ADDRESS_PUBLIC_MINT = 3;
                              function getAuctionPrice() public view returns (uint256) {
                                  AuctionInfo memory info = auctionInfo;
                                  if (block.timestamp < info.auctionSaleStartTime) {
                                      return info.auctionStartPrice;
                                  }
                                  if (
                                      block.timestamp - info.auctionSaleStartTime >=
                                      info.auctionPriceCurveLength
                                  ) {
                                      return info.auctionEndPrice;
                                  } else {
                                      uint256 steps = (block.timestamp - info.auctionSaleStartTime) /
                                          info.auctionDropInterval;
                                      uint256 auctionDropPerStep = (info.auctionStartPrice -
                                          info.auctionEndPrice) /
                                          (info.auctionPriceCurveLength / info.auctionDropInterval);
                                      return info.auctionStartPrice - (steps * auctionDropPerStep);
                                  }
                              }
                              modifier isEOA() {
                                  require(tx.origin == msg.sender, "The caller is another contract");
                                  _;
                              }
                              function auctionMint(uint8 amount, bytes calldata _signature)
                                  external
                                  payable
                                  isEOA
                              {
                                  AuctionInfo memory info = auctionInfo;
                                  if (
                                      info.auctionSaleStartTime == 0 ||
                                      block.timestamp < info.auctionSaleStartTime
                                  ) {
                                      revert AuctionMintNotOpen();
                                  }
                                  uint16 totalPresaleAndAuctionMintedLocal = totalPresaleAndAuctionMinted;
                                  if (
                                      amount + totalPresaleAndAuctionMintedLocal >
                                      TOTAL_PRESALE_AND_AUCTION_SUPPLY
                                  ) {
                                      revert MaxPresaleOrAuctionMintSupplyReached();
                                  }
                                  if (_totalMinted() + amount > MAX_SUPPLY) {
                                      revert OverMaxSupply();
                                  }
                                  uint256 numAuctionMintedForThisAddr = _getAux(msg.sender);
                                  if (
                                      numAuctionMintedForThisAddr + amount > MAX_PER_ADDRESS_PUBLIC_MINT
                                  ) {
                                      revert MaxAuctionMintForAddress();
                                  }
                                  if (!_verifySig(_signature)) revert InvalidSignature();
                                  uint256 totalCost = getAuctionPrice() * amount;
                                  if (msg.value < totalCost) {
                                      revert InsufficientFunds();
                                  }
                                  unchecked {
                                      _setAux(msg.sender, uint64(numAuctionMintedForThisAddr) + amount);
                                      totalPresaleAndAuctionMinted =
                                          totalPresaleAndAuctionMintedLocal +
                                          amount;
                                  }
                                  _mint(msg.sender, amount);
                                  if (msg.value > totalCost) {
                                      (bool sent, ) = msg.sender.call{value: msg.value - totalCost}("");
                                      if (!sent) {
                                          revert RefundFailed();
                                      }
                                  }
                              }
                              function getNumAuctionMinted(address addr) external view returns (uint256) {
                                  return _getAux(addr);
                              }
                              function setAuctionParams(
                                  uint32 _startTime,
                                  uint64 _startPriceWei,
                                  uint64 _endPriceWei,
                                  uint32 _priceCurveNumSeconds,
                                  uint32 _dropIntervalNumSeconds
                              ) public onlyOwner {
                                  if (
                                      _startTime != 0 &&
                                      (_startPriceWei == 0 ||
                                          _priceCurveNumSeconds == 0 ||
                                          _dropIntervalNumSeconds == 0)
                                  ) {
                                      revert InvalidAuctionSetup();
                                  }
                                  auctionInfo = AuctionInfo(
                                      _startTime,
                                      _startPriceWei,
                                      _endPriceWei,
                                      _priceCurveNumSeconds,
                                      _dropIntervalNumSeconds
                                  );
                              }
                              function setAuctionSaleStartTime(uint32 timestamp) external onlyOwner {
                                  AuctionInfo memory info = auctionInfo;
                                  if (
                                      timestamp != 0 &&
                                      (info.auctionStartPrice == 0 ||
                                          info.auctionPriceCurveLength == 0 ||
                                          info.auctionDropInterval == 0)
                                  ) {
                                      revert InvalidAuctionSetup();
                                  }
                                  auctionInfo.auctionSaleStartTime = timestamp;
                              }
                              function _verifySig(bytes memory _signature) private view returns (bool) {
                                  bytes32 hashVal = keccak256(abi.encodePacked(msg.sender));
                                  bytes32 signedHash = hashVal.toEthSignedMessageHash();
                                  address signingAddress = signedHash.recover(_signature);
                                  return signingAddress == _offchainSigner;
                              }
                              function withdraw() external {
                                  (bool sent, ) = WITHDRAW_ADDRESS.call{value: address(this).balance}("");
                                  if (!sent) {
                                      revert WithdrawFailed();
                                  }
                              }
                              // -----------
                              // Redeem bean
                              // -----------
                              function redeemBeans(uint256[] calldata beanIds)
                                  external
                                  returns (uint256[] memory)
                              {
                                  RedeemInfo memory info = redeemInfo;
                                  if (!info.redeemBeanOpen) {
                                      revert RedeemBeanNotOpen();
                                  }
                                  return _redeemBeansImpl(msg.sender, beanIds, true, info.beanRedeemer);
                              }
                              function _redeemBeansImpl(
                                  address beanOwner,
                                  uint256[] memory beanIds,
                                  bool burnOwnerOrApprovedCheck,
                                  address beanRedeemer
                              ) private returns (uint256[] memory) {
                                  for (uint256 i; i < beanIds.length; ) {
                                      _burn(beanIds[i], burnOwnerOrApprovedCheck);
                                      unchecked {
                                          ++i;
                                      }
                                  }
                                  return IBeanRedeemer(beanRedeemer).redeemBeans(beanOwner, beanIds);
                              }
                              function forceRedeemBeans(address beanOwner, uint256[] calldata beanIds)
                                  external
                                  onlyOwner
                                  returns (uint256[] memory)
                              {
                                  for (uint256 i; i < beanIds.length; ) {
                                      if (ownerOf(beanIds[i]) != beanOwner) {
                                          revert ForceRedeemBeanOwnerMismatch();
                                      }
                                      unchecked {
                                          ++i;
                                      }
                                  }
                                  return
                                      _redeemBeansImpl(
                                          beanOwner,
                                          beanIds,
                                          false,
                                          redeemInfo.beanRedeemer
                                      );
                              }
                              function openRedeemBeanState() external onlyOwner {
                                  RedeemInfo memory info = redeemInfo;
                                  if (info.beanRedeemer == address(0)) {
                                      revert BeanRedeemerNotSet();
                                  }
                                  redeemInfo = RedeemInfo(true, info.beanRedeemer);
                              }
                              function setBeanRedeemer(address contractAddress) external onlyOwner {
                                  redeemInfo = RedeemInfo(redeemInfo.redeemBeanOpen, contractAddress);
                              }
                              // --------------
                              // Allowlist mint
                              // --------------
                              function allowlistMint() external payable {
                                  if (allowlistMintPrice == 0) {
                                      revert AllowlistMintNotOpen();
                                  }
                                  uint256 amount = allowlistMintsAlloc[msg.sender];
                                  uint256 totalCost = allowlistMintPrice * amount;
                                  if (msg.value < totalCost) {
                                      revert InsufficientFunds();
                                  }
                                  if (_totalMinted() + amount > MAX_SUPPLY) {
                                      revert OverMaxSupply();
                                  }
                                  allowlistMintsAlloc[msg.sender] = 0;
                                  _safeMint(msg.sender, amount);
                              }
                              function setAllowlistMintsAlloc(
                                  address[] calldata addresses,
                                  uint256[] calldata amounts
                              ) external onlyOwner {
                                  if (addresses.length != amounts.length || addresses.length == 0)
                                      revert MismatchedArrays();
                                  for (uint256 i; i < addresses.length; ) {
                                      allowlistMintsAlloc[addresses[i]] = amounts[i];
                                      unchecked {
                                          ++i;
                                      }
                                  }
                              }
                              function setAllowlistMintPrice(uint256 price) external onlyOwner {
                                  allowlistMintPrice = price;
                              }
                              // -------------------
                              // Break transfer lock
                              // -------------------
                              function breakTransferLock() external onlyOwner {
                                  initialTransferLockOn = false;
                              }
                              // --------
                              // Metadata
                              // --------
                              function _baseURI() internal view override returns (string memory) {
                                  return _baseTokenURI;
                              }
                              function setBaseURI(string calldata baseURI) external onlyOwner {
                                  _baseTokenURI = baseURI;
                              }
                              // --------
                              // EIP-2981
                              // --------
                              function setDefaultRoyalty(address receiver, uint96 feeNumerator)
                                  external
                                  onlyOwner
                              {
                                  _setDefaultRoyalty(receiver, feeNumerator);
                              }
                              function setTokenRoyalty(
                                  uint256 tokenId,
                                  address receiver,
                                  uint96 feeNumerator
                              ) external onlyOwner {
                                  _setTokenRoyalty(tokenId, receiver, feeNumerator);
                              }
                              // ---------------------------------------------------
                              // OperatorFilterer overrides (overrides, values etc.)
                              // ---------------------------------------------------
                              function setApprovalForAll(address operator, bool approved)
                                  public
                                  override(ERC721A)
                                  onlyAllowedOperatorApproval(operator)
                              {
                                  if (initialTransferLockOn) revert InitialTransferLockOn();
                                  super.setApprovalForAll(operator, approved);
                              }
                              function setOperatorFilteringEnabled(bool value) public onlyOwner {
                                  operatorFilteringEnabled = value;
                              }
                              function _operatorFilteringEnabled() internal view override returns (bool) {
                                  return operatorFilteringEnabled;
                              }
                              function approve(address operator, uint256 tokenId)
                                  public
                                  payable
                                  override(ERC721A)
                                  onlyAllowedOperatorApproval(operator)
                              {
                                  if (initialTransferLockOn) revert InitialTransferLockOn();
                                  super.approve(operator, tokenId);
                              }
                              // ERC721A calls transferFrom internally in its two safeTransferFrom functions, so we don't need to override those.
                              function transferFrom(
                                  address from,
                                  address to,
                                  uint256 tokenId
                              ) public payable override(ERC721A) onlyAllowedOperator(from) {
                                  super.transferFrom(from, to, tokenId);
                              }
                              // --------------
                              // Registry check
                              // --------------
                              function _beforeTokenTransfers(
                                  address from,
                                  address to,
                                  uint256 startTokenId,
                                  uint256 quantity
                              ) internal override {
                                  if (initialTransferLockOn && from != address(0) && to != address(0))
                                      revert InitialTransferLockOn();
                                  if (_isValidAgainstRegistry(msg.sender)) {
                                      super._beforeTokenTransfers(from, to, startTokenId, quantity);
                                  } else {
                                      revert NotAllowedByRegistry();
                                  }
                              }
                              function _isValidAgainstRegistry(address operator)
                                  internal
                                  view
                                  returns (bool)
                              {
                                  if (isRegistryActive) {
                                      IRegistry registry = IRegistry(registryAddress);
                                      return registry.isAllowedOperator(operator);
                                  }
                                  return true;
                              }
                              function setIsRegistryActive(bool _isRegistryActive) external onlyOwner {
                                  if (registryAddress == address(0)) revert RegistryNotSet();
                                  isRegistryActive = _isRegistryActive;
                              }
                              function setRegistryAddress(address _registryAddress) external onlyOwner {
                                  registryAddress = _registryAddress;
                              }
                              // ----------------------------------------------
                              // EIP-165
                              // ----------------------------------------------
                              function supportsInterface(bytes4 interfaceId)
                                  public
                                  view
                                  override(ERC721A, ERC2981)
                                  returns (bool)
                              {
                                  return
                                      ERC721A.supportsInterface(interfaceId) ||
                                      ERC2981.supportsInterface(interfaceId);
                              }
                          }
                          // SPDX-License-Identifier: MIT
                          // ERC721A Contracts v4.2.3
                          // Creator: Chiru Labs
                          pragma solidity ^0.8.4;
                          import './IERC721A.sol';
                          /**
                           * @dev Interface of ERC721 token receiver.
                           */
                          interface ERC721A__IERC721Receiver {
                              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 ERC721A is IERC721A {
                              // Bypass for a `--via-ir` bug (https://github.com/chiru-labs/ERC721A/pull/364).
                              struct TokenApprovalRef {
                                  address value;
                              }
                              // =============================================================
                              //                           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;
                              // =============================================================
                              //                            STORAGE
                              // =============================================================
                              // The next token ID to be minted.
                              uint256 private _currentIndex;
                              // The number of tokens burned.
                              uint256 private _burnCounter;
                              // Token name
                              string private _name;
                              // Token symbol
                              string private _symbol;
                              // Mapping from token ID to ownership details
                              // An empty struct value does not necessarily mean the token is unowned.
                              // See {_packedOwnershipOf} implementation for details.
                              //
                              // Bits Layout:
                              // - [0..159]   `addr`
                              // - [160..223] `startTimestamp`
                              // - [224]      `burned`
                              // - [225]      `nextInitialized`
                              // - [232..255] `extraData`
                              mapping(uint256 => uint256) private _packedOwnerships;
                              // Mapping owner address to address data.
                              //
                              // Bits Layout:
                              // - [0..63]    `balance`
                              // - [64..127]  `numberMinted`
                              // - [128..191] `numberBurned`
                              // - [192..255] `aux`
                              mapping(address => uint256) private _packedAddressData;
                              // Mapping from token ID to approved address.
                              mapping(uint256 => TokenApprovalRef) private _tokenApprovals;
                              // Mapping from owner to operator approvals
                              mapping(address => mapping(address => bool)) private _operatorApprovals;
                              // =============================================================
                              //                          CONSTRUCTOR
                              // =============================================================
                              constructor(string memory name_, string memory symbol_) {
                                  _name = name_;
                                  _symbol = symbol_;
                                  _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 _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 _currentIndex - _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 _currentIndex - _startTokenId();
                                  }
                              }
                              /**
                               * @dev Returns the total number of tokens burned.
                               */
                              function _totalBurned() internal view virtual returns (uint256) {
                                  return _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.selector);
                                  return _packedAddressData[owner] & _BITMASK_ADDRESS_DATA_ENTRY;
                              }
                              /**
                               * Returns the number of tokens minted by `owner`.
                               */
                              function _numberMinted(address owner) internal view returns (uint256) {
                                  return (_packedAddressData[owner] >> _BITPOS_NUMBER_MINTED) & _BITMASK_ADDRESS_DATA_ENTRY;
                              }
                              /**
                               * Returns the number of tokens burned by or on behalf of `owner`.
                               */
                              function _numberBurned(address owner) internal view returns (uint256) {
                                  return (_packedAddressData[owner] >> _BITPOS_NUMBER_BURNED) & _BITMASK_ADDRESS_DATA_ENTRY;
                              }
                              /**
                               * Returns the auxiliary data for `owner`. (e.g. number of whitelist mint slots used).
                               */
                              function _getAux(address owner) internal view returns (uint64) {
                                  return uint64(_packedAddressData[owner] >> _BITPOS_AUX);
                              }
                              /**
                               * Sets the 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 = _packedAddressData[owner];
                                  uint256 auxCasted;
                                  // Cast `aux` with assembly to avoid redundant masking.
                                  assembly {
                                      auxCasted := aux
                                  }
                                  packed = (packed & _BITMASK_AUX_COMPLEMENT) | (auxCasted << _BITPOS_AUX);
                                  _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 _name;
                              }
                              /**
                               * @dev Returns the token collection symbol.
                               */
                              function symbol() public view virtual override returns (string memory) {
                                  return _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.selector);
                                  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(_packedOwnerships[index]);
                              }
                              /**
                               * @dev Returns whether the ownership slot at `index` is initialized.
                               * An uninitialized slot does not necessarily mean that the slot has no owner.
                               */
                              function _ownershipIsInitialized(uint256 index) internal view virtual returns (bool) {
                                  return _packedOwnerships[index] != 0;
                              }
                              /**
                               * @dev Initializes the ownership slot minted at `index` for efficiency purposes.
                               */
                              function _initializeOwnershipAt(uint256 index) internal virtual {
                                  if (_packedOwnerships[index] == 0) {
                                      _packedOwnerships[index] = _packedOwnershipOf(index);
                                  }
                              }
                              /**
                               * Returns the packed ownership data of `tokenId`.
                               */
                              function _packedOwnershipOf(uint256 tokenId) private view returns (uint256 packed) {
                                  if (_startTokenId() <= tokenId) {
                                      packed = _packedOwnerships[tokenId];
                                      // If the data at the starting slot does not exist, start the scan.
                                      if (packed == 0) {
                                          if (tokenId >= _currentIndex) _revert(OwnerQueryForNonexistentToken.selector);
                                          // 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, `tokenId` will not underflow.
                                          //
                                          // We can directly compare the packed value.
                                          // If the address is zero, packed will be zero.
                                          for (;;) {
                                              unchecked {
                                                  packed = _packedOwnerships[--tokenId];
                                              }
                                              if (packed == 0) continue;
                                              if (packed & _BITMASK_BURNED == 0) return packed;
                                              // Otherwise, the token is burned, and we must revert.
                                              // This handles the case of batch burned tokens, where only the burned bit
                                              // of the starting slot is set, and remaining slots are left uninitialized.
                                              _revert(OwnerQueryForNonexistentToken.selector);
                                          }
                                      }
                                      // Otherwise, the data exists and we can skip the scan.
                                      // This is possible because we have already achieved the target condition.
                                      // This saves 2143 gas on transfers of initialized tokens.
                                      // If the token is not burned, return `packed`. Otherwise, revert.
                                      if (packed & _BITMASK_BURNED == 0) return packed;
                                  }
                                  _revert(OwnerQueryForNonexistentToken.selector);
                              }
                              /**
                               * @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. See {ERC721A-_approve}.
                               *
                               * Requirements:
                               *
                               * - The caller must own the token or be an approved operator.
                               */
                              function approve(address to, uint256 tokenId) public payable virtual override {
                                  _approve(to, tokenId, true);
                              }
                              /**
                               * @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.selector);
                                  return _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 {
                                  _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 _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 result) {
                                  if (_startTokenId() <= tokenId) {
                                      if (tokenId < _currentIndex) {
                                          uint256 packed;
                                          while ((packed = _packedOwnerships[tokenId]) == 0) --tokenId;
                                          result = packed & _BITMASK_BURNED == 0;
                                      }
                                  }
                              }
                              /**
                               * @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)
                              {
                                  TokenApprovalRef storage tokenApproval = _tokenApprovals[tokenId];
                                  // The following is equivalent to `approvedAddress = _tokenApprovals[tokenId].value`.
                                  assembly {
                                      approvedAddressSlot := tokenApproval.slot
                                      approvedAddress := sload(approvedAddressSlot)
                                  }
                              }
                              // =============================================================
                              //                      TRANSFER OPERATIONS
                              // =============================================================
                              /**
                               * @dev Transfers `tokenId` from `from` to `to`.
                               *
                               * Requirements:
                               *
                               * - `from` cannot be the zero address.
                               * - `to` cannot be the zero address.
                               * - `tokenId` token must be owned by `from`.
                               * - If the caller is not `from`, it must be approved to move this token
                               * by either {approve} or {setApprovalForAll}.
                               *
                               * Emits a {Transfer} event.
                               */
                              function transferFrom(
                                  address from,
                                  address to,
                                  uint256 tokenId
                              ) public payable virtual override {
                                  uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);
                                  // Mask `from` to the lower 160 bits, in case the upper bits somehow aren't clean.
                                  from = address(uint160(uint256(uint160(from)) & _BITMASK_ADDRESS));
                                  if (address(uint160(prevOwnershipPacked)) != from) _revert(TransferFromIncorrectOwner.selector);
                                  (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.selector);
                                  _beforeTokenTransfers(from, to, tokenId, 1);
                                  // Clear approvals from the previous owner.
                                  assembly {
                                      if approvedAddress {
                                          // This is equivalent to `delete _tokenApprovals[tokenId]`.
                                          sstore(approvedAddressSlot, 0)
                                      }
                                  }
                                  // Underflow of the sender's balance is impossible because we check for
                                  // ownership above and the recipient's balance can't realistically overflow.
                                  // Counter overflow is incredibly unrealistic as `tokenId` would have to be 2**256.
                                  unchecked {
                                      // We can directly increment and decrement the balances.
                                      --_packedAddressData[from]; // Updates: `balance -= 1`.
                                      ++_packedAddressData[to]; // Updates: `balance += 1`.
                                      // Updates:
                                      // - `address` to the next owner.
                                      // - `startTimestamp` to the timestamp of transfering.
                                      // - `burned` to `false`.
                                      // - `nextInitialized` to `true`.
                                      _packedOwnerships[tokenId] = _packOwnershipData(
                                          to,
                                          _BITMASK_NEXT_INITIALIZED | _nextExtraData(from, to, prevOwnershipPacked)
                                      );
                                      // If the next slot may not have been initialized (i.e. `nextInitialized == false`) .
                                      if (prevOwnershipPacked & _BITMASK_NEXT_INITIALIZED == 0) {
                                          uint256 nextTokenId = tokenId + 1;
                                          // If the next slot's address is zero and not burned (i.e. packed value is zero).
                                          if (_packedOwnerships[nextTokenId] == 0) {
                                              // If the next slot is within bounds.
                                              if (nextTokenId != _currentIndex) {
                                                  // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.
                                                  _packedOwnerships[nextTokenId] = prevOwnershipPacked;
                                              }
                                          }
                                      }
                                  }
                                  // Mask `to` to the lower 160 bits, in case the upper bits somehow aren't clean.
                                  uint256 toMasked = uint256(uint160(to)) & _BITMASK_ADDRESS;
                                  assembly {
                                      // 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.
                                          from, // `from`.
                                          toMasked, // `to`.
                                          tokenId // `tokenId`.
                                      )
                                  }
                                  if (toMasked == 0) _revert(TransferToZeroAddress.selector);
                                  _afterTokenTransfers(from, to, tokenId, 1);
                              }
                              /**
                               * @dev Equivalent to `safeTransferFrom(from, to, tokenId, '')`.
                               */
                              function safeTransferFrom(
                                  address from,
                                  address to,
                                  uint256 tokenId
                              ) public payable virtual override {
                                  safeTransferFrom(from, to, tokenId, '');
                              }
                              /**
                               * @dev Safely transfers `tokenId` token from `from` to `to`.
                               *
                               * Requirements:
                               *
                               * - `from` cannot be the zero address.
                               * - `to` cannot be the zero address.
                               * - `tokenId` token must exist and be owned by `from`.
                               * - If the caller is not `from`, it must be approved to move this token
                               * by either {approve} or {setApprovalForAll}.
                               * - If `to` refers to a smart contract, it must implement
                               * {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
                               *
                               * Emits a {Transfer} event.
                               */
                              function safeTransferFrom(
                                  address from,
                                  address to,
                                  uint256 tokenId,
                                  bytes memory _data
                              ) public payable virtual override {
                                  transferFrom(from, to, tokenId);
                                  if (to.code.length != 0)
                                      if (!_checkContractOnERC721Received(from, to, tokenId, _data)) {
                                          _revert(TransferToNonERC721ReceiverImplementer.selector);
                                      }
                              }
                              /**
                               * @dev Hook that is called before a set of serially-ordered token IDs
                               * are about to be transferred. This includes minting.
                               * And also called before burning one token.
                               *
                               * `startTokenId` - the first token ID to be transferred.
                               * `quantity` - the amount to be transferred.
                               *
                               * Calling conditions:
                               *
                               * - When `from` and `to` are both non-zero, `from`'s `tokenId` will be
                               * transferred to `to`.
                               * - When `from` is zero, `tokenId` will be minted for `to`.
                               * - When `to` is zero, `tokenId` will be burned by `from`.
                               * - `from` and `to` are never both zero.
                               */
                              function _beforeTokenTransfers(
                                  address from,
                                  address to,
                                  uint256 startTokenId,
                                  uint256 quantity
                              ) internal virtual {}
                              /**
                               * @dev Hook that is called after a set of serially-ordered token IDs
                               * have been transferred. This includes minting.
                               * And also called after one token has been burned.
                               *
                               * `startTokenId` - the first token ID to be transferred.
                               * `quantity` - the amount to be transferred.
                               *
                               * Calling conditions:
                               *
                               * - When `from` and `to` are both non-zero, `from`'s `tokenId` has been
                               * transferred to `to`.
                               * - When `from` is zero, `tokenId` has been minted for `to`.
                               * - When `to` is zero, `tokenId` has been burned by `from`.
                               * - `from` and `to` are never both zero.
                               */
                              function _afterTokenTransfers(
                                  address from,
                                  address to,
                                  uint256 startTokenId,
                                  uint256 quantity
                              ) internal virtual {}
                              /**
                               * @dev Private function to invoke {IERC721Receiver-onERC721Received} on a target contract.
                               *
                               * `from` - Previous owner of the given token ID.
                               * `to` - Target address that will receive the token.
                               * `tokenId` - Token ID to be transferred.
                               * `_data` - Optional data to send along with the call.
                               *
                               * Returns whether the call correctly returned the expected magic value.
                               */
                              function _checkContractOnERC721Received(
                                  address from,
                                  address to,
                                  uint256 tokenId,
                                  bytes memory _data
                              ) private returns (bool) {
                                  try ERC721A__IERC721Receiver(to).onERC721Received(_msgSenderERC721A(), from, tokenId, _data) returns (
                                      bytes4 retval
                                  ) {
                                      return retval == ERC721A__IERC721Receiver(to).onERC721Received.selector;
                                  } catch (bytes memory reason) {
                                      if (reason.length == 0) {
                                          _revert(TransferToNonERC721ReceiverImplementer.selector);
                                      }
                                      assembly {
                                          revert(add(32, reason), mload(reason))
                                      }
                                  }
                              }
                              // =============================================================
                              //                        MINT OPERATIONS
                              // =============================================================
                              /**
                               * @dev Mints `quantity` tokens and transfers them to `to`.
                               *
                               * Requirements:
                               *
                               * - `to` cannot be the zero address.
                               * - `quantity` must be greater than 0.
                               *
                               * Emits a {Transfer} event for each mint.
                               */
                              function _mint(address to, uint256 quantity) internal virtual {
                                  uint256 startTokenId = _currentIndex;
                                  if (quantity == 0) _revert(MintZeroQuantity.selector);
                                  _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:
                                      // - `address` to the owner.
                                      // - `startTimestamp` to the timestamp of minting.
                                      // - `burned` to `false`.
                                      // - `nextInitialized` to `quantity == 1`.
                                      _packedOwnerships[startTokenId] = _packOwnershipData(
                                          to,
                                          _nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)
                                      );
                                      // Updates:
                                      // - `balance += quantity`.
                                      // - `numberMinted += quantity`.
                                      //
                                      // We can directly add to the `balance` and `numberMinted`.
                                      _packedAddressData[to] += quantity * ((1 << _BITPOS_NUMBER_MINTED) | 1);
                                      // Mask `to` to the lower 160 bits, in case the upper bits somehow aren't clean.
                                      uint256 toMasked = uint256(uint160(to)) & _BITMASK_ADDRESS;
                                      if (toMasked == 0) _revert(MintToZeroAddress.selector);
                                      uint256 end = startTokenId + quantity;
                                      uint256 tokenId = startTokenId;
                                      do {
                                          assembly {
                                              // 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`.
                                                  tokenId // `tokenId`.
                                              )
                                          }
                                          // The `!=` check ensures that large values of `quantity`
                                          // that overflows uint256 will make the loop run out of gas.
                                      } while (++tokenId != end);
                                      _currentIndex = end;
                                  }
                                  _afterTokenTransfers(address(0), to, startTokenId, quantity);
                              }
                              /**
                               * @dev Mints `quantity` tokens and transfers them to `to`.
                               *
                               * This function is intended for efficient minting only during contract creation.
                               *
                               * It emits only one {ConsecutiveTransfer} as defined in
                               * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309),
                               * instead of a sequence of {Transfer} event(s).
                               *
                               * Calling this function outside of contract creation WILL make your contract
                               * non-compliant with the ERC721 standard.
                               * For full ERC721 compliance, substituting ERC721 {Transfer} event(s) with the ERC2309
                               * {ConsecutiveTransfer} event is only permissible during contract creation.
                               *
                               * Requirements:
                               *
                               * - `to` cannot be the zero address.
                               * - `quantity` must be greater than 0.
                               *
                               * Emits a {ConsecutiveTransfer} event.
                               */
                              function _mintERC2309(address to, uint256 quantity) internal virtual {
                                  uint256 startTokenId = _currentIndex;
                                  if (to == address(0)) _revert(MintToZeroAddress.selector);
                                  if (quantity == 0) _revert(MintZeroQuantity.selector);
                                  if (quantity > _MAX_MINT_ERC2309_QUANTITY_LIMIT) _revert(MintERC2309QuantityExceedsLimit.selector);
                                  _beforeTokenTransfers(address(0), to, startTokenId, quantity);
                                  // Overflows are unrealistic due to the above check for `quantity` to be below the limit.
                                  unchecked {
                                      // Updates:
                                      // - `balance += quantity`.
                                      // - `numberMinted += quantity`.
                                      //
                                      // We can directly add to the `balance` and `numberMinted`.
                                      _packedAddressData[to] += quantity * ((1 << _BITPOS_NUMBER_MINTED) | 1);
                                      // Updates:
                                      // - `address` to the owner.
                                      // - `startTimestamp` to the timestamp of minting.
                                      // - `burned` to `false`.
                                      // - `nextInitialized` to `quantity == 1`.
                                      _packedOwnerships[startTokenId] = _packOwnershipData(
                                          to,
                                          _nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)
                                      );
                                      emit ConsecutiveTransfer(startTokenId, startTokenId + quantity - 1, address(0), to);
                                      _currentIndex = startTokenId + quantity;
                                  }
                                  _afterTokenTransfers(address(0), to, startTokenId, quantity);
                              }
                              /**
                               * @dev Safely mints `quantity` tokens and transfers them to `to`.
                               *
                               * Requirements:
                               *
                               * - If `to` refers to a smart contract, it must implement
                               * {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
                               * - `quantity` must be greater than 0.
                               *
                               * See {_mint}.
                               *
                               * Emits a {Transfer} event for each mint.
                               */
                              function _safeMint(
                                  address to,
                                  uint256 quantity,
                                  bytes memory _data
                              ) internal virtual {
                                  _mint(to, quantity);
                                  unchecked {
                                      if (to.code.length != 0) {
                                          uint256 end = _currentIndex;
                                          uint256 index = end - quantity;
                                          do {
                                              if (!_checkContractOnERC721Received(address(0), to, index++, _data)) {
                                                  _revert(TransferToNonERC721ReceiverImplementer.selector);
                                              }
                                          } while (index < end);
                                          // Reentrancy protection.
                                          if (_currentIndex != end) _revert(bytes4(0));
                                      }
                                  }
                              }
                              /**
                               * @dev Equivalent to `_safeMint(to, quantity, '')`.
                               */
                              function _safeMint(address to, uint256 quantity) internal virtual {
                                  _safeMint(to, quantity, '');
                              }
                              // =============================================================
                              //                       APPROVAL OPERATIONS
                              // =============================================================
                              /**
                               * @dev Equivalent to `_approve(to, tokenId, false)`.
                               */
                              function _approve(address to, uint256 tokenId) internal virtual {
                                  _approve(to, tokenId, false);
                              }
                              /**
                               * @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:
                               *
                               * - `tokenId` must exist.
                               *
                               * Emits an {Approval} event.
                               */
                              function _approve(
                                  address to,
                                  uint256 tokenId,
                                  bool approvalCheck
                              ) internal virtual {
                                  address owner = ownerOf(tokenId);
                                  if (approvalCheck && _msgSenderERC721A() != owner)
                                      if (!isApprovedForAll(owner, _msgSenderERC721A())) {
                                          _revert(ApprovalCallerNotOwnerNorApproved.selector);
                                      }
                                  _tokenApprovals[tokenId].value = to;
                                  emit Approval(owner, to, tokenId);
                              }
                              // =============================================================
                              //                        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.selector);
                                  }
                                  _beforeTokenTransfers(from, address(0), tokenId, 1);
                                  // Clear approvals from the previous owner.
                                  assembly {
                                      if approvedAddress {
                                          // This is equivalent to `delete _tokenApprovals[tokenId]`.
                                          sstore(approvedAddressSlot, 0)
                                      }
                                  }
                                  // Underflow of the sender's balance is impossible because we check for
                                  // ownership above and the recipient's balance can't realistically overflow.
                                  // Counter overflow is incredibly unrealistic as `tokenId` would have to be 2**256.
                                  unchecked {
                                      // Updates:
                                      // - `balance -= 1`.
                                      // - `numberBurned += 1`.
                                      //
                                      // We can directly decrement the balance, and increment the number burned.
                                      // This is equivalent to `packed -= 1; packed += 1 << _BITPOS_NUMBER_BURNED;`.
                                      _packedAddressData[from] += (1 << _BITPOS_NUMBER_BURNED) - 1;
                                      // Updates:
                                      // - `address` to the last owner.
                                      // - `startTimestamp` to the timestamp of burning.
                                      // - `burned` to `true`.
                                      // - `nextInitialized` to `true`.
                                      _packedOwnerships[tokenId] = _packOwnershipData(
                                          from,
                                          (_BITMASK_BURNED | _BITMASK_NEXT_INITIALIZED) | _nextExtraData(from, address(0), prevOwnershipPacked)
                                      );
                                      // If the next slot may not have been initialized (i.e. `nextInitialized == false`) .
                                      if (prevOwnershipPacked & _BITMASK_NEXT_INITIALIZED == 0) {
                                          uint256 nextTokenId = tokenId + 1;
                                          // If the next slot's address is zero and not burned (i.e. packed value is zero).
                                          if (_packedOwnerships[nextTokenId] == 0) {
                                              // If the next slot is within bounds.
                                              if (nextTokenId != _currentIndex) {
                                                  // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.
                                                  _packedOwnerships[nextTokenId] = prevOwnershipPacked;
                                              }
                                          }
                                      }
                                  }
                                  emit Transfer(from, address(0), tokenId);
                                  _afterTokenTransfers(from, address(0), tokenId, 1);
                                  // Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.
                                  unchecked {
                                      _burnCounter++;
                                  }
                              }
                              // =============================================================
                              //                     EXTRA DATA OPERATIONS
                              // =============================================================
                              /**
                               * @dev Directly sets the extra data for the ownership data `index`.
                               */
                              function _setExtraDataAt(uint256 index, uint24 extraData) internal virtual {
                                  uint256 packed = _packedOwnerships[index];
                                  if (packed == 0) _revert(OwnershipNotInitializedForExtraData.selector);
                                  uint256 extraDataCasted;
                                  // Cast `extraData` with assembly to avoid redundant masking.
                                  assembly {
                                      extraDataCasted := extraData
                                  }
                                  packed = (packed & _BITMASK_EXTRA_DATA_COMPLEMENT) | (extraDataCasted << _BITPOS_EXTRA_DATA);
                                  _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 0xa0 bytes to keep the free memory pointer 32-byte word aligned.
                                      // We will need 1 word for the trailing zeros padding, 1 word for the length,
                                      // and 3 words for a maximum of 78 digits. Total: 5 * 0x20 = 0xa0.
                                      let m := add(mload(0x40), 0xa0)
                                      // Update the free memory pointer to allocate.
                                      mstore(0x40, m)
                                      // Assign the `str` to the end.
                                      str := sub(m, 0x20)
                                      // Zeroize the slot after the string.
                                      mstore(str, 0)
                                      // 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)
                                  }
                              }
                              /**
                               * @dev For more efficient reverts.
                               */
                              function _revert(bytes4 errorSelector) internal pure {
                                  assembly {
                                      mstore(0x00, errorSelector)
                                      revert(0x00, 0x04)
                                  }
                              }
                          }
                          // SPDX-License-Identifier: MIT
                          // OpenZeppelin Contracts (last updated v4.7.0) (token/common/ERC2981.sol)
                          pragma solidity ^0.8.0;
                          import "../../interfaces/IERC2981.sol";
                          import "../../utils/introspection/ERC165.sol";
                          /**
                           * @dev Implementation of the NFT Royalty Standard, a standardized way to retrieve royalty payment information.
                           *
                           * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for
                           * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first.
                           *
                           * Royalty is specified as a fraction of sale price. {_feeDenominator} is overridable but defaults to 10000, meaning the
                           * fee is specified in basis points by default.
                           *
                           * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See
                           * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to
                           * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported.
                           *
                           * _Available since v4.5._
                           */
                          abstract contract ERC2981 is IERC2981, ERC165 {
                              struct RoyaltyInfo {
                                  address receiver;
                                  uint96 royaltyFraction;
                              }
                              RoyaltyInfo private _defaultRoyaltyInfo;
                              mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo;
                              /**
                               * @dev See {IERC165-supportsInterface}.
                               */
                              function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC165) returns (bool) {
                                  return interfaceId == type(IERC2981).interfaceId || super.supportsInterface(interfaceId);
                              }
                              /**
                               * @inheritdoc IERC2981
                               */
                              function royaltyInfo(uint256 tokenId, uint256 salePrice) public view virtual override returns (address, uint256) {
                                  RoyaltyInfo memory royalty = _tokenRoyaltyInfo[tokenId];
                                  if (royalty.receiver == address(0)) {
                                      royalty = _defaultRoyaltyInfo;
                                  }
                                  uint256 royaltyAmount = (salePrice * royalty.royaltyFraction) / _feeDenominator();
                                  return (royalty.receiver, royaltyAmount);
                              }
                              /**
                               * @dev The denominator with which to interpret the fee set in {_setTokenRoyalty} and {_setDefaultRoyalty} as a
                               * fraction of the sale price. Defaults to 10000 so fees are expressed in basis points, but may be customized by an
                               * override.
                               */
                              function _feeDenominator() internal pure virtual returns (uint96) {
                                  return 10000;
                              }
                              /**
                               * @dev Sets the royalty information that all ids in this contract will default to.
                               *
                               * Requirements:
                               *
                               * - `receiver` cannot be the zero address.
                               * - `feeNumerator` cannot be greater than the fee denominator.
                               */
                              function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual {
                                  require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
                                  require(receiver != address(0), "ERC2981: invalid receiver");
                                  _defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator);
                              }
                              /**
                               * @dev Removes default royalty information.
                               */
                              function _deleteDefaultRoyalty() internal virtual {
                                  delete _defaultRoyaltyInfo;
                              }
                              /**
                               * @dev Sets the royalty information for a specific token id, overriding the global default.
                               *
                               * Requirements:
                               *
                               * - `receiver` cannot be the zero address.
                               * - `feeNumerator` cannot be greater than the fee denominator.
                               */
                              function _setTokenRoyalty(uint256 tokenId, address receiver, uint96 feeNumerator) internal virtual {
                                  require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
                                  require(receiver != address(0), "ERC2981: Invalid parameters");
                                  _tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator);
                              }
                              /**
                               * @dev Resets royalty information for the token id back to the global default.
                               */
                              function _resetTokenRoyalty(uint256 tokenId) internal virtual {
                                  delete _tokenRoyaltyInfo[tokenId];
                              }
                          }
                          // SPDX-License-Identifier: MIT
                          // OpenZeppelin Contracts (last updated v4.8.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.
                           *
                           * ```solidity
                           * 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
                          // OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/ECDSA.sol)
                          pragma solidity ^0.8.0;
                          import "../Strings.sol";
                          /**
                           * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
                           *
                           * These functions can be used to verify that a message was signed by the holder
                           * of the private keys of a given address.
                           */
                          library ECDSA {
                              enum RecoverError {
                                  NoError,
                                  InvalidSignature,
                                  InvalidSignatureLength,
                                  InvalidSignatureS,
                                  InvalidSignatureV // Deprecated in v4.8
                              }
                              function _throwError(RecoverError error) private pure {
                                  if (error == RecoverError.NoError) {
                                      return; // no error: do nothing
                                  } else if (error == RecoverError.InvalidSignature) {
                                      revert("ECDSA: invalid signature");
                                  } else if (error == RecoverError.InvalidSignatureLength) {
                                      revert("ECDSA: invalid signature length");
                                  } else if (error == RecoverError.InvalidSignatureS) {
                                      revert("ECDSA: invalid signature 's' value");
                                  }
                              }
                              /**
                               * @dev Returns the address that signed a hashed message (`hash`) with
                               * `signature` or error string. This address can then be used for verification purposes.
                               *
                               * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
                               * this function rejects them by requiring the `s` value to be in the lower
                               * half order, and the `v` value to be either 27 or 28.
                               *
                               * IMPORTANT: `hash` _must_ be the result of a hash operation for the
                               * verification to be secure: it is possible to craft signatures that
                               * recover to arbitrary addresses for non-hashed data. A safe way to ensure
                               * this is by receiving a hash of the original message (which may otherwise
                               * be too long), and then calling {toEthSignedMessageHash} on it.
                               *
                               * Documentation for signature generation:
                               * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
                               * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
                               *
                               * _Available since v4.3._
                               */
                              function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
                                  if (signature.length == 65) {
                                      bytes32 r;
                                      bytes32 s;
                                      uint8 v;
                                      // ecrecover takes the signature parameters, and the only way to get them
                                      // currently is to use assembly.
                                      /// @solidity memory-safe-assembly
                                      assembly {
                                          r := mload(add(signature, 0x20))
                                          s := mload(add(signature, 0x40))
                                          v := byte(0, mload(add(signature, 0x60)))
                                      }
                                      return tryRecover(hash, v, r, s);
                                  } else {
                                      return (address(0), RecoverError.InvalidSignatureLength);
                                  }
                              }
                              /**
                               * @dev Returns the address that signed a hashed message (`hash`) with
                               * `signature`. This address can then be used for verification purposes.
                               *
                               * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
                               * this function rejects them by requiring the `s` value to be in the lower
                               * half order, and the `v` value to be either 27 or 28.
                               *
                               * IMPORTANT: `hash` _must_ be the result of a hash operation for the
                               * verification to be secure: it is possible to craft signatures that
                               * recover to arbitrary addresses for non-hashed data. A safe way to ensure
                               * this is by receiving a hash of the original message (which may otherwise
                               * be too long), and then calling {toEthSignedMessageHash} on it.
                               */
                              function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
                                  (address recovered, RecoverError error) = tryRecover(hash, signature);
                                  _throwError(error);
                                  return recovered;
                              }
                              /**
                               * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
                               *
                               * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
                               *
                               * _Available since v4.3._
                               */
                              function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError) {
                                  bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
                                  uint8 v = uint8((uint256(vs) >> 255) + 27);
                                  return tryRecover(hash, v, r, s);
                              }
                              /**
                               * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
                               *
                               * _Available since v4.2._
                               */
                              function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
                                  (address recovered, RecoverError error) = tryRecover(hash, r, vs);
                                  _throwError(error);
                                  return recovered;
                              }
                              /**
                               * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
                               * `r` and `s` signature fields separately.
                               *
                               * _Available since v4.3._
                               */
                              function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address, RecoverError) {
                                  // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
                                  // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
                                  // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
                                  // signatures from current libraries generate a unique signature with an s-value in the lower half order.
                                  //
                                  // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
                                  // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
                                  // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
                                  // these malleable signatures as well.
                                  if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
                                      return (address(0), RecoverError.InvalidSignatureS);
                                  }
                                  // If the signature is valid (and not malleable), return the signer address
                                  address signer = ecrecover(hash, v, r, s);
                                  if (signer == address(0)) {
                                      return (address(0), RecoverError.InvalidSignature);
                                  }
                                  return (signer, RecoverError.NoError);
                              }
                              /**
                               * @dev Overload of {ECDSA-recover} that receives the `v`,
                               * `r` and `s` signature fields separately.
                               */
                              function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
                                  (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
                                  _throwError(error);
                                  return recovered;
                              }
                              /**
                               * @dev Returns an Ethereum Signed Message, created from a `hash`. This
                               * produces hash corresponding to the one signed with the
                               * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
                               * JSON-RPC method as part of EIP-191.
                               *
                               * See {recover}.
                               */
                              function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 message) {
                                  // 32 is the length in bytes of hash,
                                  // enforced by the type signature above
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      mstore(0x00, "\\x19Ethereum Signed Message:\
                          32")
                                      mstore(0x1c, hash)
                                      message := keccak256(0x00, 0x3c)
                                  }
                              }
                              /**
                               * @dev Returns an Ethereum Signed Message, created from `s`. This
                               * produces hash corresponding to the one signed with the
                               * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
                               * JSON-RPC method as part of EIP-191.
                               *
                               * See {recover}.
                               */
                              function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
                                  return keccak256(abi.encodePacked("\\x19Ethereum Signed Message:\
                          ", Strings.toString(s.length), s));
                              }
                              /**
                               * @dev Returns an Ethereum Signed Typed Data, created from a
                               * `domainSeparator` and a `structHash`. This produces hash corresponding
                               * to the one signed with the
                               * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
                               * JSON-RPC method as part of EIP-712.
                               *
                               * See {recover}.
                               */
                              function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 data) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      let ptr := mload(0x40)
                                      mstore(ptr, "\\x19\\x01")
                                      mstore(add(ptr, 0x02), domainSeparator)
                                      mstore(add(ptr, 0x22), structHash)
                                      data := keccak256(ptr, 0x42)
                                  }
                              }
                              /**
                               * @dev Returns an Ethereum Signed Data with intended validator, created from a
                               * `validator` and `data` according to the version 0 of EIP-191.
                               *
                               * See {recover}.
                               */
                              function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
                                  return keccak256(abi.encodePacked("\\x19\\x00", validator, data));
                              }
                          }
                          // SPDX-License-Identifier: MIT
                          // OpenZeppelin Contracts (last updated v4.8.0) (utils/structs/BitMaps.sol)
                          pragma solidity ^0.8.0;
                          /**
                           * @dev Library for managing uint256 to bool mapping in a compact and efficient way, providing the keys are sequential.
                           * Largely inspired by Uniswap's https://github.com/Uniswap/merkle-distributor/blob/master/contracts/MerkleDistributor.sol[merkle-distributor].
                           */
                          library BitMaps {
                              struct BitMap {
                                  mapping(uint256 => uint256) _data;
                              }
                              /**
                               * @dev Returns whether the bit at `index` is set.
                               */
                              function get(BitMap storage bitmap, uint256 index) internal view returns (bool) {
                                  uint256 bucket = index >> 8;
                                  uint256 mask = 1 << (index & 0xff);
                                  return bitmap._data[bucket] & mask != 0;
                              }
                              /**
                               * @dev Sets the bit at `index` to the boolean `value`.
                               */
                              function setTo(BitMap storage bitmap, uint256 index, bool value) internal {
                                  if (value) {
                                      set(bitmap, index);
                                  } else {
                                      unset(bitmap, index);
                                  }
                              }
                              /**
                               * @dev Sets the bit at `index`.
                               */
                              function set(BitMap storage bitmap, uint256 index) internal {
                                  uint256 bucket = index >> 8;
                                  uint256 mask = 1 << (index & 0xff);
                                  bitmap._data[bucket] |= mask;
                              }
                              /**
                               * @dev Unsets the bit at `index`.
                               */
                              function unset(BitMap storage bitmap, uint256 index) internal {
                                  uint256 bucket = index >> 8;
                                  uint256 mask = 1 << (index & 0xff);
                                  bitmap._data[bucket] &= ~mask;
                              }
                          }
                          // SPDX-License-Identifier: MIT
                          pragma solidity ^0.8.4;
                          /// @notice Optimized and flexible operator filterer to abide to OpenSea's
                          /// mandatory on-chain royalty enforcement in order for new collections to
                          /// receive royalties.
                          /// For more information, see:
                          /// See: https://github.com/ProjectOpenSea/operator-filter-registry
                          abstract contract OperatorFilterer {
                              /// @dev The default OpenSea operator blocklist subscription.
                              address internal constant _DEFAULT_SUBSCRIPTION = 0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6;
                              /// @dev The OpenSea operator filter registry.
                              address internal constant _OPERATOR_FILTER_REGISTRY = 0x000000000000AAeB6D7670E522A718067333cd4E;
                              /// @dev Registers the current contract to OpenSea's operator filter,
                              /// and subscribe to the default OpenSea operator blocklist.
                              /// Note: Will not revert nor update existing settings for repeated registration.
                              function _registerForOperatorFiltering() internal virtual {
                                  _registerForOperatorFiltering(_DEFAULT_SUBSCRIPTION, true);
                              }
                              /// @dev Registers the current contract to OpenSea's operator filter.
                              /// Note: Will not revert nor update existing settings for repeated registration.
                              function _registerForOperatorFiltering(address subscriptionOrRegistrantToCopy, bool subscribe)
                                  internal
                                  virtual
                              {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      let functionSelector := 0x7d3e3dbe // `registerAndSubscribe(address,address)`.
                                      // Clean the upper 96 bits of `subscriptionOrRegistrantToCopy` in case they are dirty.
                                      subscriptionOrRegistrantToCopy := shr(96, shl(96, subscriptionOrRegistrantToCopy))
                                      for {} iszero(subscribe) {} {
                                          if iszero(subscriptionOrRegistrantToCopy) {
                                              functionSelector := 0x4420e486 // `register(address)`.
                                              break
                                          }
                                          functionSelector := 0xa0af2903 // `registerAndCopyEntries(address,address)`.
                                          break
                                      }
                                      // Store the function selector.
                                      mstore(0x00, shl(224, functionSelector))
                                      // Store the `address(this)`.
                                      mstore(0x04, address())
                                      // Store the `subscriptionOrRegistrantToCopy`.
                                      mstore(0x24, subscriptionOrRegistrantToCopy)
                                      // Register into the registry.
                                      if iszero(call(gas(), _OPERATOR_FILTER_REGISTRY, 0, 0x00, 0x44, 0x00, 0x04)) {
                                          // If the function selector has not been overwritten,
                                          // it is an out-of-gas error.
                                          if eq(shr(224, mload(0x00)), functionSelector) {
                                              // To prevent gas under-estimation.
                                              revert(0, 0)
                                          }
                                      }
                                      // Restore the part of the free memory pointer that was overwritten,
                                      // which is guaranteed to be zero, because of Solidity's memory size limits.
                                      mstore(0x24, 0)
                                  }
                              }
                              /// @dev Modifier to guard a function and revert if the caller is a blocked operator.
                              modifier onlyAllowedOperator(address from) virtual {
                                  if (from != msg.sender) {
                                      if (!_isPriorityOperator(msg.sender)) {
                                          if (_operatorFilteringEnabled()) _revertIfBlocked(msg.sender);
                                      }
                                  }
                                  _;
                              }
                              /// @dev Modifier to guard a function from approving a blocked operator..
                              modifier onlyAllowedOperatorApproval(address operator) virtual {
                                  if (!_isPriorityOperator(operator)) {
                                      if (_operatorFilteringEnabled()) _revertIfBlocked(operator);
                                  }
                                  _;
                              }
                              /// @dev Helper function that reverts if the `operator` is blocked by the registry.
                              function _revertIfBlocked(address operator) private view {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      // Store the function selector of `isOperatorAllowed(address,address)`,
                                      // shifted left by 6 bytes, which is enough for 8tb of memory.
                                      // We waste 6-3 = 3 bytes to save on 6 runtime gas (PUSH1 0x224 SHL).
                                      mstore(0x00, 0xc6171134001122334455)
                                      // Store the `address(this)`.
                                      mstore(0x1a, address())
                                      // Store the `operator`.
                                      mstore(0x3a, operator)
                                      // `isOperatorAllowed` always returns true if it does not revert.
                                      if iszero(staticcall(gas(), _OPERATOR_FILTER_REGISTRY, 0x16, 0x44, 0x00, 0x00)) {
                                          // Bubble up the revert if the staticcall reverts.
                                          returndatacopy(0x00, 0x00, returndatasize())
                                          revert(0x00, returndatasize())
                                      }
                                      // We'll skip checking if `from` is inside the blacklist.
                                      // Even though that can block transferring out of wrapper contracts,
                                      // we don't want tokens to be stuck.
                                      // Restore the part of the free memory pointer that was overwritten,
                                      // which is guaranteed to be zero, if less than 8tb of memory is used.
                                      mstore(0x3a, 0)
                                  }
                              }
                              /// @dev For deriving contracts to override, so that operator filtering
                              /// can be turned on / off.
                              /// Returns true by default.
                              function _operatorFilteringEnabled() internal view virtual returns (bool) {
                                  return true;
                              }
                              /// @dev For deriving contracts to override, so that preferred marketplaces can
                              /// skip operator filtering, helping users save gas.
                              /// Returns false for all inputs by default.
                              function _isPriorityOperator(address) internal view virtual returns (bool) {
                                  return false;
                              }
                          }
                          // SPDX-License-Identifier: CC0-1.0
                          // Source: https://github.com/tubby-cats/dual-ownership-nft
                          pragma solidity ^0.8.4;
                          import '@openzeppelin/contracts/access/Ownable.sol';
                          abstract contract MultisigOwnable is Ownable {
                            address public realOwner;
                            constructor() {
                              realOwner = msg.sender;
                            }
                            modifier onlyRealOwner() {
                              require(
                                realOwner == msg.sender,
                                'MultisigOwnable: caller is not the real owner'
                              );
                              _;
                            }
                            function transferRealOwnership(address newRealOwner) public onlyRealOwner {
                              realOwner = newRealOwner;
                            }
                            function transferLowerOwnership(address newOwner) public onlyRealOwner {
                              transferOwnership(newOwner);
                            }
                          }// SPDX-License-Identifier: MIT
                          // ERC721A Contracts v4.2.3
                          // Creator: Chiru Labs
                          pragma solidity ^0.8.4;
                          /**
                           * @dev Interface of ERC721A.
                           */
                          interface IERC721A {
                              /**
                               * The caller must own the token or be an approved operator.
                               */
                              error ApprovalCallerNotOwnerNorApproved();
                              /**
                               * The token does not exist.
                               */
                              error ApprovalQueryForNonexistentToken();
                              /**
                               * 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 payable;
                              /**
                               * @dev Equivalent to `safeTransferFrom(from, to, tokenId, '')`.
                               */
                              function safeTransferFrom(
                                  address from,
                                  address to,
                                  uint256 tokenId
                              ) external payable;
                              /**
                               * @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 payable;
                              /**
                               * @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 payable;
                              /**
                               * @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);
                          }
                          // SPDX-License-Identifier: MIT
                          // OpenZeppelin Contracts (last updated v4.6.0) (interfaces/IERC2981.sol)
                          pragma solidity ^0.8.0;
                          import "../utils/introspection/IERC165.sol";
                          /**
                           * @dev Interface for the NFT Royalty Standard.
                           *
                           * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal
                           * support for royalty payments across all NFT marketplaces and ecosystem participants.
                           *
                           * _Available since v4.5._
                           */
                          interface IERC2981 is IERC165 {
                              /**
                               * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of
                               * exchange. The royalty amount is denominated and should be paid in that same unit of exchange.
                               */
                              function royaltyInfo(
                                  uint256 tokenId,
                                  uint256 salePrice
                              ) external view returns (address receiver, uint256 royaltyAmount);
                          }
                          // SPDX-License-Identifier: MIT
                          // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
                          pragma solidity ^0.8.0;
                          import "./IERC165.sol";
                          /**
                           * @dev Implementation of the {IERC165} interface.
                           *
                           * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
                           * for the additional interface id that will be supported. For example:
                           *
                           * ```solidity
                           * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
                           *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
                           * }
                           * ```
                           *
                           * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
                           */
                          abstract contract ERC165 is IERC165 {
                              /**
                               * @dev See {IERC165-supportsInterface}.
                               */
                              function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
                                  return interfaceId == type(IERC165).interfaceId;
                              }
                          }
                          // SPDX-License-Identifier: MIT
                          // OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)
                          pragma solidity ^0.8.0;
                          import "./math/Math.sol";
                          import "./math/SignedMath.sol";
                          /**
                           * @dev String operations.
                           */
                          library Strings {
                              bytes16 private constant _SYMBOLS = "0123456789abcdef";
                              uint8 private constant _ADDRESS_LENGTH = 20;
                              /**
                               * @dev Converts a `uint256` to its ASCII `string` decimal representation.
                               */
                              function toString(uint256 value) internal pure returns (string memory) {
                                  unchecked {
                                      uint256 length = Math.log10(value) + 1;
                                      string memory buffer = new string(length);
                                      uint256 ptr;
                                      /// @solidity memory-safe-assembly
                                      assembly {
                                          ptr := add(buffer, add(32, length))
                                      }
                                      while (true) {
                                          ptr--;
                                          /// @solidity memory-safe-assembly
                                          assembly {
                                              mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                                          }
                                          value /= 10;
                                          if (value == 0) break;
                                      }
                                      return buffer;
                                  }
                              }
                              /**
                               * @dev Converts a `int256` to its ASCII `string` decimal representation.
                               */
                              function toString(int256 value) internal pure returns (string memory) {
                                  return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
                              }
                              /**
                               * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
                               */
                              function toHexString(uint256 value) internal pure returns (string memory) {
                                  unchecked {
                                      return toHexString(value, Math.log256(value) + 1);
                                  }
                              }
                              /**
                               * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
                               */
                              function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
                                  bytes memory buffer = new bytes(2 * length + 2);
                                  buffer[0] = "0";
                                  buffer[1] = "x";
                                  for (uint256 i = 2 * length + 1; i > 1; --i) {
                                      buffer[i] = _SYMBOLS[value & 0xf];
                                      value >>= 4;
                                  }
                                  require(value == 0, "Strings: hex length insufficient");
                                  return string(buffer);
                              }
                              /**
                               * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
                               */
                              function toHexString(address addr) internal pure returns (string memory) {
                                  return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
                              }
                              /**
                               * @dev Returns true if the two strings are equal.
                               */
                              function equal(string memory a, string memory b) internal pure returns (bool) {
                                  return keccak256(bytes(a)) == keccak256(bytes(b));
                              }
                          }
                          // 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. Can only be called by the current owner.
                               *
                               * NOTE: Renouncing ownership will leave the contract without an owner,
                               * thereby disabling 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/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
                          // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)
                          pragma solidity ^0.8.0;
                          /**
                           * @dev Standard math utilities missing in the Solidity language.
                           */
                          library Math {
                              enum Rounding {
                                  Down, // Toward negative infinity
                                  Up, // Toward infinity
                                  Zero // Toward zero
                              }
                              /**
                               * @dev Returns the largest of two numbers.
                               */
                              function max(uint256 a, uint256 b) internal pure returns (uint256) {
                                  return a > b ? a : b;
                              }
                              /**
                               * @dev Returns the smallest of two numbers.
                               */
                              function min(uint256 a, uint256 b) internal pure returns (uint256) {
                                  return a < b ? a : b;
                              }
                              /**
                               * @dev Returns the average of two numbers. The result is rounded towards
                               * zero.
                               */
                              function average(uint256 a, uint256 b) internal pure returns (uint256) {
                                  // (a + b) / 2 can overflow.
                                  return (a & b) + (a ^ b) / 2;
                              }
                              /**
                               * @dev Returns the ceiling of the division of two numbers.
                               *
                               * This differs from standard division with `/` in that it rounds up instead
                               * of rounding down.
                               */
                              function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
                                  // (a + b - 1) / b can overflow on addition, so we distribute.
                                  return a == 0 ? 0 : (a - 1) / b + 1;
                              }
                              /**
                               * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
                               * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
                               * with further edits by Uniswap Labs also under MIT license.
                               */
                              function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
                                  unchecked {
                                      // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
                                      // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
                                      // variables such that product = prod1 * 2^256 + prod0.
                                      uint256 prod0; // Least significant 256 bits of the product
                                      uint256 prod1; // Most significant 256 bits of the product
                                      assembly {
                                          let mm := mulmod(x, y, not(0))
                                          prod0 := mul(x, y)
                                          prod1 := sub(sub(mm, prod0), lt(mm, prod0))
                                      }
                                      // Handle non-overflow cases, 256 by 256 division.
                                      if (prod1 == 0) {
                                          // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                                          // The surrounding unchecked block does not change this fact.
                                          // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                                          return prod0 / denominator;
                                      }
                                      // Make sure the result is less than 2^256. Also prevents denominator == 0.
                                      require(denominator > prod1, "Math: mulDiv overflow");
                                      ///////////////////////////////////////////////
                                      // 512 by 256 division.
                                      ///////////////////////////////////////////////
                                      // Make division exact by subtracting the remainder from [prod1 prod0].
                                      uint256 remainder;
                                      assembly {
                                          // Compute remainder using mulmod.
                                          remainder := mulmod(x, y, denominator)
                                          // Subtract 256 bit number from 512 bit number.
                                          prod1 := sub(prod1, gt(remainder, prod0))
                                          prod0 := sub(prod0, remainder)
                                      }
                                      // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
                                      // See https://cs.stackexchange.com/q/138556/92363.
                                      // Does not overflow because the denominator cannot be zero at this stage in the function.
                                      uint256 twos = denominator & (~denominator + 1);
                                      assembly {
                                          // Divide denominator by twos.
                                          denominator := div(denominator, twos)
                                          // Divide [prod1 prod0] by twos.
                                          prod0 := div(prod0, twos)
                                          // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                                          twos := add(div(sub(0, twos), twos), 1)
                                      }
                                      // Shift in bits from prod1 into prod0.
                                      prod0 |= prod1 * twos;
                                      // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
                                      // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
                                      // four bits. That is, denominator * inv = 1 mod 2^4.
                                      uint256 inverse = (3 * denominator) ^ 2;
                                      // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
                                      // in modular arithmetic, doubling the correct bits in each step.
                                      inverse *= 2 - denominator * inverse; // inverse mod 2^8
                                      inverse *= 2 - denominator * inverse; // inverse mod 2^16
                                      inverse *= 2 - denominator * inverse; // inverse mod 2^32
                                      inverse *= 2 - denominator * inverse; // inverse mod 2^64
                                      inverse *= 2 - denominator * inverse; // inverse mod 2^128
                                      inverse *= 2 - denominator * inverse; // inverse mod 2^256
                                      // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
                                      // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
                                      // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
                                      // is no longer required.
                                      result = prod0 * inverse;
                                      return result;
                                  }
                              }
                              /**
                               * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
                               */
                              function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
                                  uint256 result = mulDiv(x, y, denominator);
                                  if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
                                      result += 1;
                                  }
                                  return result;
                              }
                              /**
                               * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
                               *
                               * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
                               */
                              function sqrt(uint256 a) internal pure returns (uint256) {
                                  if (a == 0) {
                                      return 0;
                                  }
                                  // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
                                  //
                                  // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
                                  // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
                                  //
                                  // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
                                  // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
                                  // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
                                  //
                                  // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
                                  uint256 result = 1 << (log2(a) >> 1);
                                  // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
                                  // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
                                  // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
                                  // into the expected uint128 result.
                                  unchecked {
                                      result = (result + a / result) >> 1;
                                      result = (result + a / result) >> 1;
                                      result = (result + a / result) >> 1;
                                      result = (result + a / result) >> 1;
                                      result = (result + a / result) >> 1;
                                      result = (result + a / result) >> 1;
                                      result = (result + a / result) >> 1;
                                      return min(result, a / result);
                                  }
                              }
                              /**
                               * @notice Calculates sqrt(a), following the selected rounding direction.
                               */
                              function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
                                  unchecked {
                                      uint256 result = sqrt(a);
                                      return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
                                  }
                              }
                              /**
                               * @dev Return the log in base 2, rounded down, of a positive value.
                               * Returns 0 if given 0.
                               */
                              function log2(uint256 value) internal pure returns (uint256) {
                                  uint256 result = 0;
                                  unchecked {
                                      if (value >> 128 > 0) {
                                          value >>= 128;
                                          result += 128;
                                      }
                                      if (value >> 64 > 0) {
                                          value >>= 64;
                                          result += 64;
                                      }
                                      if (value >> 32 > 0) {
                                          value >>= 32;
                                          result += 32;
                                      }
                                      if (value >> 16 > 0) {
                                          value >>= 16;
                                          result += 16;
                                      }
                                      if (value >> 8 > 0) {
                                          value >>= 8;
                                          result += 8;
                                      }
                                      if (value >> 4 > 0) {
                                          value >>= 4;
                                          result += 4;
                                      }
                                      if (value >> 2 > 0) {
                                          value >>= 2;
                                          result += 2;
                                      }
                                      if (value >> 1 > 0) {
                                          result += 1;
                                      }
                                  }
                                  return result;
                              }
                              /**
                               * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
                               * Returns 0 if given 0.
                               */
                              function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
                                  unchecked {
                                      uint256 result = log2(value);
                                      return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
                                  }
                              }
                              /**
                               * @dev Return the log in base 10, rounded down, of a positive value.
                               * Returns 0 if given 0.
                               */
                              function log10(uint256 value) internal pure returns (uint256) {
                                  uint256 result = 0;
                                  unchecked {
                                      if (value >= 10 ** 64) {
                                          value /= 10 ** 64;
                                          result += 64;
                                      }
                                      if (value >= 10 ** 32) {
                                          value /= 10 ** 32;
                                          result += 32;
                                      }
                                      if (value >= 10 ** 16) {
                                          value /= 10 ** 16;
                                          result += 16;
                                      }
                                      if (value >= 10 ** 8) {
                                          value /= 10 ** 8;
                                          result += 8;
                                      }
                                      if (value >= 10 ** 4) {
                                          value /= 10 ** 4;
                                          result += 4;
                                      }
                                      if (value >= 10 ** 2) {
                                          value /= 10 ** 2;
                                          result += 2;
                                      }
                                      if (value >= 10 ** 1) {
                                          result += 1;
                                      }
                                  }
                                  return result;
                              }
                              /**
                               * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
                               * Returns 0 if given 0.
                               */
                              function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
                                  unchecked {
                                      uint256 result = log10(value);
                                      return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
                                  }
                              }
                              /**
                               * @dev Return the log in base 256, rounded down, of a positive value.
                               * Returns 0 if given 0.
                               *
                               * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
                               */
                              function log256(uint256 value) internal pure returns (uint256) {
                                  uint256 result = 0;
                                  unchecked {
                                      if (value >> 128 > 0) {
                                          value >>= 128;
                                          result += 16;
                                      }
                                      if (value >> 64 > 0) {
                                          value >>= 64;
                                          result += 8;
                                      }
                                      if (value >> 32 > 0) {
                                          value >>= 32;
                                          result += 4;
                                      }
                                      if (value >> 16 > 0) {
                                          value >>= 16;
                                          result += 2;
                                      }
                                      if (value >> 8 > 0) {
                                          result += 1;
                                      }
                                  }
                                  return result;
                              }
                              /**
                               * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
                               * Returns 0 if given 0.
                               */
                              function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
                                  unchecked {
                                      uint256 result = log256(value);
                                      return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
                                  }
                              }
                          }
                          // SPDX-License-Identifier: MIT
                          // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)
                          pragma solidity ^0.8.0;
                          /**
                           * @dev Standard signed math utilities missing in the Solidity language.
                           */
                          library SignedMath {
                              /**
                               * @dev Returns the largest of two signed numbers.
                               */
                              function max(int256 a, int256 b) internal pure returns (int256) {
                                  return a > b ? a : b;
                              }
                              /**
                               * @dev Returns the smallest of two signed numbers.
                               */
                              function min(int256 a, int256 b) internal pure returns (int256) {
                                  return a < b ? a : b;
                              }
                              /**
                               * @dev Returns the average of two signed numbers without overflow.
                               * The result is rounded towards zero.
                               */
                              function average(int256 a, int256 b) internal pure returns (int256) {
                                  // Formula from the book "Hacker's Delight"
                                  int256 x = (a & b) + ((a ^ b) >> 1);
                                  return x + (int256(uint256(x) >> 255) & (a ^ b));
                              }
                              /**
                               * @dev Returns the absolute unsigned value of a signed value.
                               */
                              function abs(int256 n) internal pure returns (uint256) {
                                  unchecked {
                                      // must be unchecked in order to support `n = type(int256).min`
                                      return uint256(n >= 0 ? n : -n);
                                  }
                              }
                          }
                          // 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;
                              }
                          }
                          

                          File 3 of 10: ERC1967Proxy
                          // SPDX-License-Identifier: MIT
                          // OpenZeppelin Contracts v4.4.1 (proxy/ERC1967/ERC1967Proxy.sol)
                          pragma solidity 0.8.17;
                          // OpenZeppelin Contracts v4.4.1 (proxy/Proxy.sol)
                          /**
                           * @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 {
                                  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 {}
                          }
                          // OpenZeppelin Contracts v4.4.1 (proxy/ERC1967/ERC1967Upgrade.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 {
                                  _upgradeTo(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
                                      _upgradeTo(newImplementation);
                                  }
                              }
                              /**
                               * @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;
                              }
                              /**
                               * @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 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();
                              }
                          }
                          // OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)
                          /**
                           * @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);
                          }
                          // OpenZeppelin Contracts v4.4.1 (utils/Address.sol)
                          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;
                                  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");
                                  (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");
                                  (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");
                                  (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");
                                  (bool success, bytes memory returndata) = target.delegatecall(data);
                                  return verifyCallResult(success, returndata, errorMessage);
                              }
                              /**
                               * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
                               * revert reason 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 {
                                      // 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
                                          assembly {
                                              let returndata_size := mload(returndata)
                                              revert(add(32, returndata), returndata_size)
                                          }
                                      } else {
                                          revert(errorMessage);
                                      }
                                  }
                              }
                          }
                          // OpenZeppelin Contracts v4.4.1 (utils/StorageSlot.sol)
                          /**
                           * @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
                                  }
                              }
                          }

                          File 4 of 10: ERC1967Proxy
                          // SPDX-License-Identifier: MIT
                          // OpenZeppelin Contracts v4.4.1 (proxy/ERC1967/ERC1967Proxy.sol)
                          pragma solidity 0.8.17;
                          import "lib/openzeppelin-contracts/contracts/proxy/Proxy.sol";
                          import "lib/openzeppelin-contracts/contracts/proxy/ERC1967/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
                          // OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)
                          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 internal call site, it will return directly to the external caller.
                               */
                              function _delegate(address implementation) internal virtual {
                                  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 overridden 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 internal 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 overridden should call `super._beforeFallback()`.
                               */
                              function _beforeFallback() internal virtual {}
                          }
                          // SPDX-License-Identifier: MIT
                          // OpenZeppelin Contracts (last updated v4.8.3) (proxy/ERC1967/ERC1967Upgrade.sol)
                          pragma solidity ^0.8.2;
                          import "../beacon/IBeacon.sol";
                          import "../../interfaces/IERC1967.sol";
                          import "../../interfaces/draft-IERC1822.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._
                           */
                          abstract contract ERC1967Upgrade is IERC1967 {
                              // 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 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 {
                                  _upgradeTo(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 _upgradeToAndCallUUPS(address newImplementation, bytes memory data, bool forceCall) internal {
                                  // Upgrades from old implementations will perform a rollback test. This test requires the new
                                  // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
                                  // this special case will break upgrade paths from old UUPS implementation to new ones.
                                  if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {
                                      _setImplementation(newImplementation);
                                  } else {
                                      try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
                                          require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
                                      } catch {
                                          revert("ERC1967Upgrade: new implementation is not UUPS");
                                      }
                                      _upgradeToAndCall(newImplementation, data, forceCall);
                                  }
                              }
                              /**
                               * @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 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 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;
                              }
                              /**
                               * @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);
                                  }
                              }
                          }
                          // SPDX-License-Identifier: MIT
                          // OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)
                          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 ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC.
                           *
                           * _Available since v4.8.3._
                           */
                          interface IERC1967 {
                              /**
                               * @dev Emitted when the implementation is upgraded.
                               */
                              event Upgraded(address indexed implementation);
                              /**
                               * @dev Emitted when the admin account has changed.
                               */
                              event AdminChanged(address previousAdmin, address newAdmin);
                              /**
                               * @dev Emitted when the beacon is changed.
                               */
                              event BeaconUpgraded(address indexed beacon);
                          }
                          // SPDX-License-Identifier: MIT
                          // OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)
                          pragma solidity ^0.8.0;
                          /**
                           * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
                           * proxy whose upgrades are fully controlled by the current implementation.
                           */
                          interface IERC1822Proxiable {
                              /**
                               * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
                               * address.
                               *
                               * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
                               * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
                               * function revert if invoked through a proxy.
                               */
                              function proxiableUUID() external view returns (bytes32);
                          }
                          // 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 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
                               *
                               * Furthermore, `isContract` will also return true if the target contract within
                               * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
                               * which only has an effect at the end of a transaction.
                               * ====
                               *
                               * [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://consensys.net/diligence/blog/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.8.0/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 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) {
                                  (bool success, bytes memory returndata) = target.delegatecall(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 (last updated v4.7.0) (utils/StorageSlot.sol)
                          // This file was procedurally generated from scripts/generate/templates/StorageSlot.js.
                          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:
                           * ```solidity
                           * 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`, `uint256`._
                           * _Available since v4.9 for `string`, `bytes`._
                           */
                          library StorageSlot {
                              struct AddressSlot {
                                  address value;
                              }
                              struct BooleanSlot {
                                  bool value;
                              }
                              struct Bytes32Slot {
                                  bytes32 value;
                              }
                              struct Uint256Slot {
                                  uint256 value;
                              }
                              struct StringSlot {
                                  string value;
                              }
                              struct BytesSlot {
                                  bytes value;
                              }
                              /**
                               * @dev Returns an `AddressSlot` with member `value` located at `slot`.
                               */
                              function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r.slot := slot
                                  }
                              }
                              /**
                               * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
                               */
                              function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r.slot := slot
                                  }
                              }
                              /**
                               * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
                               */
                              function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r.slot := slot
                                  }
                              }
                              /**
                               * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
                               */
                              function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r.slot := slot
                                  }
                              }
                              /**
                               * @dev Returns an `StringSlot` with member `value` located at `slot`.
                               */
                              function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r.slot := slot
                                  }
                              }
                              /**
                               * @dev Returns an `StringSlot` representation of the string storage pointer `store`.
                               */
                              function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r.slot := store.slot
                                  }
                              }
                              /**
                               * @dev Returns an `BytesSlot` with member `value` located at `slot`.
                               */
                              function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r.slot := slot
                                  }
                              }
                              /**
                               * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
                               */
                              function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r.slot := store.slot
                                  }
                              }
                          }
                          

                          File 5 of 10: Blend
                          // SPDX-License-Identifier: BSL 1.1 - Blend (c) Non Fungible Trading Ltd.
                          pragma solidity 0.8.17;
                          import "lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/UUPSUpgradeable.sol";
                          import "./Helpers.sol";
                          import "./lib/Structs.sol";
                          import "./OfferController.sol";
                          import "./interfaces/IBlend.sol";
                          import "../pool/interfaces/IBlurPool.sol";
                          contract Blend is IBlend, OfferController, UUPSUpgradeable {
                              IExchange private immutable _EXCHANGE;
                              IExchangeV2 private immutable _EXCHANGE_V2;
                              IBlurPool private immutable _POOL;
                              address private immutable _SELL_MATCHING_POLICY;
                              address private immutable _BID_MATCHING_POLICY;
                              address private immutable _DELEGATE;
                              address private immutable _DELEGATE_V2;
                              uint256 private constant _BASIS_POINTS = 10_000;
                              uint256 private constant _MAX_AUCTION_DURATION = 432_000;
                              uint256 private constant _LIQUIDATION_THRESHOLD = 100_000;
                              uint256 private _nextLienId;
                              mapping(uint256 => bytes32) public liens;
                              mapping(bytes32 => uint256) public amountTaken;
                              // required by the OZ UUPS module
                              function _authorizeUpgrade(address) internal override onlyOwner {}
                              constructor(
                                  address pool,
                                  address exchange,
                                  address exchangeV2,
                                  address sellMatchingPolicy,
                                  address bidMatchingPolicy,
                                  address delegate,
                                  address delegateV2
                              ) {
                                  _POOL = IBlurPool(pool);
                                  _EXCHANGE = IExchange(exchange);
                                  _EXCHANGE_V2 = IExchangeV2(exchangeV2);
                                  _SELL_MATCHING_POLICY = sellMatchingPolicy;
                                  _BID_MATCHING_POLICY = bidMatchingPolicy;
                                  _DELEGATE = delegate;
                                  _DELEGATE_V2 = delegateV2;
                                  _disableInitializers();
                              }
                              function initialize() external initializer {
                                  __UUPSUpgradeable_init();
                                  __Ownable_init();
                              }
                              /*//////////////////////////////////////////////////
                                              BORROW FLOWS
                              //////////////////////////////////////////////////*/
                              /**
                               * @notice Verifies and takes loan offer; then transfers loan and collateral assets
                               * @param offer Loan offer
                               * @param signature Lender offer signature
                               * @param loanAmount Loan amount in ETH
                               * @param collateralTokenId Token id to provide as collateral
                               * @return lienId New lien id
                               */
                              function borrow(
                                  LoanOffer calldata offer,
                                  bytes calldata signature,
                                  uint256 loanAmount,
                                  uint256 collateralTokenId
                              ) external returns (uint256 lienId) {
                                  lienId = _borrow(offer, signature, loanAmount, collateralTokenId);
                                  /* Lock collateral token. */
                                  offer.collection.safeTransferFrom(msg.sender, address(this), collateralTokenId);
                                  /* Transfer loan to borrower. */
                                  _POOL.transferFrom(offer.lender, msg.sender, loanAmount);
                              }
                              /**
                               * @notice Repays loan and retrieves collateral
                               * @param lien Lien preimage
                               * @param lienId Lien id
                               */
                              function repay(
                                  Lien calldata lien,
                                  uint256 lienId
                              ) external validateLien(lien, lienId) lienIsActive(lien) {
                                  uint256 debt = _repay(lien, lienId);
                                  /* Return NFT to borrower. */
                                  lien.collection.safeTransferFrom(address(this), lien.borrower, lien.tokenId);
                                  /* Repay loan to lender. */
                                  _POOL.transferFrom(msg.sender, lien.lender, debt);
                              }
                              /**
                               * @notice Verifies and takes loan offer; creates new lien
                               * @param offer Loan offer
                               * @param signature Lender offer signature
                               * @param loanAmount Loan amount in ETH
                               * @param collateralTokenId Token id to provide as collateral
                               * @return lienId New lien id
                               */
                              function _borrow(
                                  LoanOffer calldata offer,
                                  bytes calldata signature,
                                  uint256 loanAmount,
                                  uint256 collateralTokenId
                              ) internal returns (uint256 lienId) {
                                  if (offer.auctionDuration > _MAX_AUCTION_DURATION) {
                                      revert InvalidAuctionDuration();
                                  }
                                  Lien memory lien = Lien({
                                      lender: offer.lender,
                                      borrower: msg.sender,
                                      collection: offer.collection,
                                      tokenId: collateralTokenId,
                                      amount: loanAmount,
                                      startTime: block.timestamp,
                                      rate: offer.rate,
                                      auctionStartBlock: 0,
                                      auctionDuration: offer.auctionDuration
                                  });
                                  /* Create lien. */
                                  unchecked {
                                      liens[lienId = _nextLienId++] = keccak256(abi.encode(lien));
                                  }
                                  /* Take the loan offer. */
                                  _takeLoanOffer(offer, signature, lien, lienId);
                              }
                              /**
                               * @notice Computes the current debt repayment and burns the lien
                               * @dev Does not transfer assets
                               * @param lien Lien preimage
                               * @param lienId Lien id
                               * @return debt Current amount of debt owed on the lien
                               */
                              function _repay(Lien calldata lien, uint256 lienId) internal returns (uint256 debt) {
                                  debt = Helpers.computeCurrentDebt(lien.amount, lien.rate, lien.startTime);
                                  delete liens[lienId];
                                  emit Repay(lienId, address(lien.collection));
                              }
                              /**
                               * @notice Verifies and takes loan offer
                               * @dev Does not transfer loan and collateral assets; does not update lien hash
                               * @param offer Loan offer
                               * @param signature Lender offer signature
                               * @param lien Lien preimage
                               * @param lienId Lien id
                               */
                              function _takeLoanOffer(
                                  LoanOffer calldata offer,
                                  bytes calldata signature,
                                  Lien memory lien,
                                  uint256 lienId
                              ) internal {
                                  bytes32 hash = _hashOffer(offer);
                                  _validateOffer(
                                      hash,
                                      offer.lender,
                                      offer.oracle,
                                      signature,
                                      offer.expirationTime,
                                      offer.salt
                                  );
                                  if (offer.rate > _LIQUIDATION_THRESHOLD) {
                                      revert RateTooHigh();
                                  }
                                  if (lien.amount > offer.maxAmount || lien.amount < offer.minAmount) {
                                      revert InvalidLoan();
                                  }
                                  uint256 _amountTaken = amountTaken[hash];
                                  if (offer.totalAmount - _amountTaken < lien.amount) {
                                      revert InsufficientOffer();
                                  }
                                  unchecked {
                                      amountTaken[hash] = _amountTaken + lien.amount;
                                  }
                                  emit LoanOfferTaken(
                                      hash,
                                      lienId,
                                      address(offer.collection),
                                      lien.lender,
                                      lien.borrower,
                                      lien.amount,
                                      lien.rate,
                                      lien.tokenId,
                                      lien.auctionDuration
                                  );
                              }
                              /*//////////////////////////////////////////////////
                                              REFINANCING FLOWS
                              //////////////////////////////////////////////////*/
                              /**
                               * @notice Starts Dutch Auction on lien ownership
                               * @dev Must be called by lien owner
                               * @param lienId Lien token id
                               */
                              function startAuction(Lien calldata lien, uint256 lienId) external validateLien(lien, lienId) {
                                  if (msg.sender != lien.lender) {
                                      revert Unauthorized();
                                  }
                                  /* Cannot start if auction has already started. */
                                  if (lien.auctionStartBlock != 0) {
                                      revert AuctionIsActive();
                                  }
                                  /* Add auction start block to lien. */
                                  liens[lienId] = keccak256(
                                      abi.encode(
                                          Lien({
                                              lender: lien.lender,
                                              borrower: lien.borrower,
                                              collection: lien.collection,
                                              tokenId: lien.tokenId,
                                              amount: lien.amount,
                                              startTime: lien.startTime,
                                              rate: lien.rate,
                                              auctionStartBlock: block.number,
                                              auctionDuration: lien.auctionDuration
                                          })
                                      )
                                  );
                                  emit StartAuction(lienId, address(lien.collection));
                              }
                              /**
                               * @notice Seizes collateral from defaulted lien, skipping liens that are not defaulted
                               * @param lienPointers List of lien, lienId pairs
                               */
                              function seize(LienPointer[] calldata lienPointers) external {
                                  uint256 length = lienPointers.length;
                                  for (uint256 i; i < length; ) {
                                      Lien calldata lien = lienPointers[i].lien;
                                      uint256 lienId = lienPointers[i].lienId;
                                      if (msg.sender != lien.lender) {
                                          revert Unauthorized();
                                      }
                                      if (!_validateLien(lien, lienId)) {
                                          revert InvalidLien();
                                      }
                                      /* Check that the auction has ended and lien is defaulted. */
                                      if (_lienIsDefaulted(lien)) {
                                          delete liens[lienId];
                                          /* Seize collateral to lender. */
                                          lien.collection.safeTransferFrom(address(this), lien.lender, lien.tokenId);
                                          emit Seize(lienId, address(lien.collection));
                                      }
                                      unchecked {
                                          ++i;
                                      }
                                  }
                              }
                              /**
                               * @notice Refinances to different loan amount and repays previous loan
                               * @dev Must be called by lender; previous loan must be repaid with interest
                               * @param lien Lien struct
                               * @param lienId Lien id
                               * @param offer Loan offer
                               * @param signature Offer signatures
                               */
                              function refinance(
                                  Lien calldata lien,
                                  uint256 lienId,
                                  LoanOffer calldata offer,
                                  bytes calldata signature
                              ) external validateLien(lien, lienId) lienIsActive(lien) {
                                  if (msg.sender != lien.lender) {
                                      revert Unauthorized();
                                  }
                                  /* Interest rate must be at least as good as current. */
                                  if (offer.rate > lien.rate || offer.auctionDuration != lien.auctionDuration) {
                                      revert InvalidRefinance();
                                  }
                                  uint256 debt = Helpers.computeCurrentDebt(lien.amount, lien.rate, lien.startTime);
                                  _refinance(lien, lienId, debt, offer, signature);
                                  /* Repay initial loan. */
                                  _POOL.transferFrom(offer.lender, lien.lender, debt);
                              }
                              /**
                               * @notice Refinance lien in auction at the current debt amount where the interest rate ceiling increases over time
                               * @dev Interest rate must be lower than the interest rate ceiling
                               * @param lien Lien struct
                               * @param lienId Lien token id
                               * @param rate Interest rate (in bips)
                               * @dev Formula: https://www.desmos.com/calculator/urasr71dhb
                               */
                              function refinanceAuction(
                                  Lien calldata lien,
                                  uint256 lienId,
                                  uint256 rate
                              ) external validateLien(lien, lienId) auctionIsActive(lien) {
                                  /* Rate must be below current rate limit. */
                                  uint256 rateLimit = Helpers.calcRefinancingAuctionRate(
                                      lien.auctionStartBlock,
                                      lien.auctionDuration,
                                      lien.rate
                                  );
                                  if (rate > rateLimit) {
                                      revert RateTooHigh();
                                  }
                                  uint256 debt = Helpers.computeCurrentDebt(lien.amount, lien.rate, lien.startTime);
                                  /* Reset the lien with the new lender and interest rate. */
                                  liens[lienId] = keccak256(
                                      abi.encode(
                                          Lien({
                                              lender: msg.sender, // set new lender
                                              borrower: lien.borrower,
                                              collection: lien.collection,
                                              tokenId: lien.tokenId,
                                              amount: debt, // new loan begins with previous debt
                                              startTime: block.timestamp,
                                              rate: rate,
                                              auctionStartBlock: 0, // close the auction
                                              auctionDuration: lien.auctionDuration
                                          })
                                      )
                                  );
                                  emit Refinance(
                                      lienId,
                                      address(lien.collection),
                                      msg.sender,
                                      debt,
                                      rate,
                                      lien.auctionDuration
                                  );
                                  /* Repay the initial loan. */
                                  _POOL.transferFrom(msg.sender, lien.lender, debt);
                              }
                              /**
                               * @notice Refinances to different loan amount and repays previous loan
                               * @param lien Lien struct
                               * @param lienId Lien id
                               * @param offer Loan offer
                               * @param signature Offer signatures
                               */
                              function refinanceAuctionByOther(
                                  Lien calldata lien,
                                  uint256 lienId,
                                  LoanOffer calldata offer,
                                  bytes calldata signature
                              ) external validateLien(lien, lienId) auctionIsActive(lien) {
                                  /* Rate must be below current rate limit and auction duration must be the same. */
                                  uint256 rateLimit = Helpers.calcRefinancingAuctionRate(
                                      lien.auctionStartBlock,
                                      lien.auctionDuration,
                                      lien.rate
                                  );
                                  if (offer.rate > rateLimit || offer.auctionDuration != lien.auctionDuration) {
                                      revert InvalidRefinance();
                                  }
                                  uint256 debt = Helpers.computeCurrentDebt(lien.amount, lien.rate, lien.startTime);
                                  _refinance(lien, lienId, debt, offer, signature);
                                  /* Repay initial loan. */
                                  _POOL.transferFrom(offer.lender, lien.lender, debt);
                              }
                              /**
                               * @notice Refinances to different loan amount and repays previous loan
                               * @dev Must be called by borrower; previous loan must be repaid with interest
                               * @param lien Lien struct
                               * @param lienId Lien id
                               * @param loanAmount New loan amount
                               * @param offer Loan offer
                               * @param signature Offer signatures
                               */
                              function borrowerRefinance(
                                  Lien calldata lien,
                                  uint256 lienId,
                                  uint256 loanAmount,
                                  LoanOffer calldata offer,
                                  bytes calldata signature
                              ) external validateLien(lien, lienId) lienIsActive(lien) {
                                  if (msg.sender != lien.borrower) {
                                      revert Unauthorized();
                                  }
                                  if (offer.auctionDuration > _MAX_AUCTION_DURATION) {
                                      revert InvalidAuctionDuration();
                                  }
                                  _refinance(lien, lienId, loanAmount, offer, signature);
                                  uint256 debt = Helpers.computeCurrentDebt(lien.amount, lien.rate, lien.startTime);
                                  if (loanAmount >= debt) {
                                      /* If new loan is more than the previous, repay the initial loan and send the remaining to the borrower. */
                                      _POOL.transferFrom(offer.lender, lien.lender, debt);
                                      unchecked {
                                          _POOL.transferFrom(offer.lender, lien.borrower, loanAmount - debt);
                                      }
                                  } else {
                                      /* If new loan is less than the previous, borrower must supply the difference to repay the initial loan. */
                                      _POOL.transferFrom(offer.lender, lien.lender, loanAmount);
                                      unchecked {
                                          _POOL.transferFrom(lien.borrower, lien.lender, debt - loanAmount);
                                      }
                                  }
                              }
                              function _refinance(
                                  Lien calldata lien,
                                  uint256 lienId,
                                  uint256 loanAmount,
                                  LoanOffer calldata offer,
                                  bytes calldata signature
                              ) internal {
                                  if (lien.collection != offer.collection) {
                                      revert CollectionsDoNotMatch();
                                  }
                                  /* Update lien with new loan details. */
                                  Lien memory newLien = Lien({
                                      lender: offer.lender, // set new lender
                                      borrower: lien.borrower,
                                      collection: lien.collection,
                                      tokenId: lien.tokenId,
                                      amount: loanAmount,
                                      startTime: block.timestamp,
                                      rate: offer.rate,
                                      auctionStartBlock: 0, // close the auction
                                      auctionDuration: offer.auctionDuration
                                  });
                                  liens[lienId] = keccak256(abi.encode(newLien));
                                  /* Take the loan offer. */
                                  _takeLoanOffer(offer, signature, newLien, lienId);
                                  emit Refinance(
                                      lienId,
                                      address(offer.collection),
                                      offer.lender,
                                      loanAmount,
                                      offer.rate,
                                      offer.auctionDuration
                                  );
                              }
                              /*/////////////////////////////////////////////////////////////
                                                    MARKETPLACE FLOWS
                              /////////////////////////////////////////////////////////////*/
                              /**
                               * @notice Purchase an NFT and use as collateral for a loan
                               * @param offer Loan offer to take
                               * @param signature Lender offer signature
                               * @param loanAmount Loan amount in ETH
                               * @param execution Marketplace execution data
                               * @return lienId Lien id
                               */
                              function buyToBorrow(
                                  LoanOffer calldata offer,
                                  bytes calldata signature,
                                  uint256 loanAmount,
                                  ExecutionV1 calldata execution
                              ) public returns (uint256 lienId) {
                                  if (execution.makerOrder.order.trader == address(this)) {
                                      revert Unauthorized();
                                  }
                                  if (offer.auctionDuration > _MAX_AUCTION_DURATION) {
                                      revert InvalidAuctionDuration();
                                  }
                                  uint256 collateralTokenId = execution.makerOrder.order.tokenId;
                                  uint256 price = execution.makerOrder.order.price;
                                  /* Create lien. */
                                  Lien memory lien = Lien({
                                      lender: offer.lender,
                                      borrower: msg.sender,
                                      collection: offer.collection,
                                      tokenId: collateralTokenId,
                                      amount: loanAmount,
                                      startTime: block.timestamp,
                                      rate: offer.rate,
                                      auctionStartBlock: 0,
                                      auctionDuration: offer.auctionDuration
                                  });
                                  unchecked {
                                      liens[lienId = _nextLienId++] = keccak256(abi.encode(lien));
                                  }
                                  /* Take the loan offer. */
                                  _takeLoanOffer(offer, signature, lien, lienId);
                                  /* Create the buy side order coming from Blend. */
                                  Helpers.executeTakeAsk(
                                      offer,
                                      execution,
                                      loanAmount,
                                      collateralTokenId,
                                      price,
                                      _POOL,
                                      _EXCHANGE,
                                      _SELL_MATCHING_POLICY
                                  );
                              }
                              function buyToBorrowV2(
                                  LoanOffer calldata offer,
                                  bytes calldata signature,
                                  uint256 loanAmount,
                                  AskExecutionV2 calldata execution
                              ) public returns (uint256 lienId) {
                                  if (offer.auctionDuration > _MAX_AUCTION_DURATION) {
                                      revert InvalidAuctionDuration();
                                  }
                                  uint256 collateralTokenId = execution.listing.tokenId;
                                  uint256 price = execution.listing.price;
                                  /* Create lien. */
                                  Lien memory lien = Lien({
                                      lender: offer.lender,
                                      borrower: msg.sender,
                                      collection: offer.collection,
                                      tokenId: collateralTokenId,
                                      amount: loanAmount,
                                      startTime: block.timestamp,
                                      rate: offer.rate,
                                      auctionStartBlock: 0,
                                      auctionDuration: offer.auctionDuration
                                  });
                                  unchecked {
                                      liens[lienId = _nextLienId++] = keccak256(abi.encode(lien));
                                  }
                                  /* Take the loan offer. */
                                  _takeLoanOffer(offer, signature, lien, lienId);
                                  /* Execute order using ETH currently in contract. */
                                  Helpers.executeTakeAskV2(
                                      offer,
                                      execution,
                                      loanAmount,
                                      collateralTokenId,
                                      price,
                                      _POOL,
                                      _EXCHANGE_V2
                                  );
                              }
                              /**
                               * @notice Purchase a locked NFT; repay the initial loan; lock the token as collateral for a new loan
                               * @param lien Lien preimage struct
                               * @param sellInput Sell offer and signature
                               * @param loanInput Loan offer and signature
                               * @return lienId Lien id
                               */
                              function buyToBorrowLocked(
                                  Lien calldata lien,
                                  SellInput calldata sellInput,
                                  LoanInput calldata loanInput,
                                  uint256 loanAmount
                              )
                                  public
                                  validateLien(lien, sellInput.offer.lienId)
                                  lienIsActive(lien)
                                  returns (uint256 lienId)
                              {
                                  if (lien.collection != loanInput.offer.collection) {
                                      revert CollectionsDoNotMatch();
                                  }
                                  (uint256 priceAfterFees, uint256 debt) = _buyLocked(
                                      lien,
                                      sellInput.offer,
                                      sellInput.signature
                                  );
                                  lienId = _borrow(loanInput.offer, loanInput.signature, loanAmount, lien.tokenId);
                                  /* Transfer funds. */
                                  /* Need to repay the original loan and payout any surplus from the sell or loan funds. */
                                  if (loanAmount < debt) {
                                      /* loanAmount < debt < priceAfterFees */
                                      /* Repay loan with funds from new lender to old lender. */
                                      _POOL.transferFrom(loanInput.offer.lender, lien.lender, loanAmount); // doesn't cover debt
                                      unchecked {
                                          /* Supplement difference from new borrower. */
                                          _POOL.transferFrom(msg.sender, lien.lender, debt - loanAmount); // cover rest of debt
                                          /* Send rest of sell funds to borrower. */
                                          _POOL.transferFrom(msg.sender, sellInput.offer.borrower, priceAfterFees - debt);
                                      }
                                  } else if (loanAmount < priceAfterFees) {
                                      /* debt < loanAmount < priceAfterFees */
                                      /* Repay loan with funds from new lender to old lender. */
                                      _POOL.transferFrom(loanInput.offer.lender, lien.lender, debt);
                                      unchecked {
                                          /* Send rest of loan from new lender to old borrower. */
                                          _POOL.transferFrom(
                                              loanInput.offer.lender,
                                              sellInput.offer.borrower,
                                              loanAmount - debt
                                          );
                                          /* Send rest of sell funds from new borrower to old borrower. */
                                          _POOL.transferFrom(
                                              msg.sender,
                                              sellInput.offer.borrower,
                                              priceAfterFees - loanAmount
                                          );
                                      }
                                  } else {
                                      /* debt < priceAfterFees < loanAmount */
                                      /* Repay loan with funds from new lender to old lender. */
                                      _POOL.transferFrom(loanInput.offer.lender, lien.lender, debt);
                                      unchecked {
                                          /* Send rest of sell funds from new lender to old borrower. */
                                          _POOL.transferFrom(
                                              loanInput.offer.lender,
                                              sellInput.offer.borrower,
                                              priceAfterFees - debt
                                          );
                                          /* Send rest of loan from new lender to new borrower. */
                                          _POOL.transferFrom(loanInput.offer.lender, msg.sender, loanAmount - priceAfterFees);
                                      }
                                  }
                              }
                              /**
                               * @notice Purchases a locked NFT and uses the funds to repay the loan
                               * @param lien Lien preimage
                               * @param offer Sell offer
                               * @param signature Lender offer signature
                               */
                              function buyLocked(
                                  Lien calldata lien,
                                  SellOffer calldata offer,
                                  bytes calldata signature
                              ) public validateLien(lien, offer.lienId) lienIsActive(lien) {
                                  (uint256 priceAfterFees, uint256 debt) = _buyLocked(lien, offer, signature);
                                  /* Send token to buyer. */
                                  lien.collection.safeTransferFrom(address(this), msg.sender, lien.tokenId);
                                  /* Repay lender. */
                                  _POOL.transferFrom(msg.sender, lien.lender, debt);
                                  /* Send surplus to borrower. */
                                  unchecked {
                                      _POOL.transferFrom(msg.sender, lien.borrower, priceAfterFees - debt);
                                  }
                              }
                              /**
                               * @notice Takes a bid on a locked NFT and use the funds to repay the lien
                               * @dev Must be called by the borrower
                               * @param lien Lien preimage
                               * @param lienId Lien id
                               * @param execution Marketplace execution data
                               */
                              function takeBid(
                                  Lien calldata lien,
                                  uint256 lienId,
                                  ExecutionV1 calldata execution
                              ) external validateLien(lien, lienId) lienIsActive(lien) {
                                  if (execution.makerOrder.order.trader == address(this) || msg.sender != lien.borrower) {
                                      revert Unauthorized();
                                  }
                                  /* Repay loan with funds received from the sale. */
                                  uint256 debt = _repay(lien, lienId);
                                  Helpers.executeTakeBid(
                                      lien,
                                      lienId,
                                      execution,
                                      debt,
                                      _POOL,
                                      _EXCHANGE,
                                      _DELEGATE,
                                      _BID_MATCHING_POLICY
                                  );
                              }
                              function takeBidV2(
                                  Lien calldata lien,
                                  uint256 lienId,
                                  BidExecutionV2 calldata execution
                              ) external validateLien(lien, lienId) lienIsActive(lien) {
                                  if (msg.sender != lien.borrower) {
                                      revert Unauthorized();
                                  }
                                  /* Repay loan with funds received from the sale. */
                                  uint256 debt = _repay(lien, lienId);
                                  Helpers.executeTakeBidV2(lien, execution, debt, _POOL, _EXCHANGE_V2, _DELEGATE_V2);
                              }
                              /**
                               * @notice Verify and take sell offer for token locked in lien; use the funds to repay the debt on the lien
                               * @dev Does not transfer assets
                               * @param lien Lien preimage
                               * @param offer Loan offer
                               * @param signature Loan offer signature
                               * @return priceAfterFees Price of the token (after fees), debt Current debt amount
                               */
                              function _buyLocked(
                                  Lien calldata lien,
                                  SellOffer calldata offer,
                                  bytes calldata signature
                              ) internal returns (uint256 priceAfterFees, uint256 debt) {
                                  if (lien.borrower != offer.borrower) {
                                      revert Unauthorized();
                                  }
                                  priceAfterFees = _takeSellOffer(offer, signature);
                                  /* Repay loan with funds received from the sale. */
                                  debt = _repay(lien, offer.lienId);
                                  if (priceAfterFees < debt) {
                                      revert InvalidRepayment();
                                  }
                                  emit BuyLocked(
                                      offer.lienId,
                                      address(lien.collection),
                                      msg.sender,
                                      lien.borrower,
                                      lien.tokenId
                                  );
                              }
                              /**
                               * @notice Validates, fulfills, and transfers fees on sell offer
                               * @param sellOffer Sell offer
                               * @param sellSignature Sell offer signature
                               */
                              function _takeSellOffer(
                                  SellOffer calldata sellOffer,
                                  bytes calldata sellSignature
                              ) internal returns (uint256 priceAfterFees) {
                                  _validateOffer(
                                      _hashSellOffer(sellOffer),
                                      sellOffer.borrower,
                                      sellOffer.oracle,
                                      sellSignature,
                                      sellOffer.expirationTime,
                                      sellOffer.salt
                                  );
                                  /* Mark the sell offer as fulfilled. */
                                  cancelledOrFulfilled[sellOffer.borrower][sellOffer.salt] = 1;
                                  /* Transfer fees. */
                                  uint256 totalFees = _transferFees(sellOffer.fees, msg.sender, sellOffer.price);
                                  unchecked {
                                      priceAfterFees = sellOffer.price - totalFees;
                                  }
                              }
                              function _transferFees(
                                  Fee[] calldata fees,
                                  address from,
                                  uint256 price
                              ) internal returns (uint256 totalFee) {
                                  uint256 feesLength = fees.length;
                                  for (uint256 i = 0; i < feesLength; ) {
                                      uint256 fee = (price * fees[i].rate) / _BASIS_POINTS;
                                      _POOL.transferFrom(from, fees[i].recipient, fee);
                                      totalFee += fee;
                                      unchecked {
                                          ++i;
                                      }
                                  }
                                  if (totalFee > price) {
                                      revert FeesTooHigh();
                                  }
                              }
                              receive() external payable {
                                  if (msg.sender != address(_POOL) && msg.sender != address(_EXCHANGE_V2)) {
                                      revert Unauthorized();
                                  }
                              }
                              function onERC721Received(
                                  address operator,
                                  address from,
                                  uint256 tokenId,
                                  bytes calldata data
                              ) external pure returns (bytes4) {
                                  return this.onERC721Received.selector;
                              }
                              /*/////////////////////////////////////////////////////////////
                                                  PAYABLE WRAPPERS
                              /////////////////////////////////////////////////////////////*/
                              /**
                               * @notice buyToBorrow wrapper that deposits ETH to pool
                               */
                              function buyToBorrowETH(
                                  LoanOffer calldata offer,
                                  bytes calldata signature,
                                  uint256 loanAmount,
                                  ExecutionV1 calldata execution
                              ) external payable returns (uint256 lienId) {
                                  _POOL.deposit{ value: msg.value }(msg.sender);
                                  return buyToBorrow(offer, signature, loanAmount, execution);
                              }
                              /**
                               * @notice buyToBorrow wrapper that deposits ETH to pool
                               */
                              function buyToBorrowV2ETH(
                                  LoanOffer calldata offer,
                                  bytes calldata signature,
                                  uint256 loanAmount,
                                  AskExecutionV2 calldata execution
                              ) external payable returns (uint256 lienId) {
                                  _POOL.deposit{ value: msg.value }(msg.sender);
                                  return buyToBorrowV2(offer, signature, loanAmount, execution);
                              }
                              /**
                               * @notice buyToBorrowLocked wrapper that deposits ETH to pool
                               */
                              function buyToBorrowLockedETH(
                                  Lien calldata lien,
                                  SellInput calldata sellInput,
                                  LoanInput calldata loanInput,
                                  uint256 loanAmount
                              ) external payable returns (uint256 lienId) {
                                  _POOL.deposit{ value: msg.value }(msg.sender);
                                  return buyToBorrowLocked(lien, sellInput, loanInput, loanAmount);
                              }
                              /**
                               * @notice buyLocked wrapper that deposits ETH to pool
                               */
                              function buyLockedETH(
                                  Lien calldata lien,
                                  SellOffer calldata offer,
                                  bytes calldata signature
                              ) external payable {
                                  _POOL.deposit{ value: msg.value }(msg.sender);
                                  return buyLocked(lien, offer, signature);
                              }
                              /*/////////////////////////////////////////////////////////////
                                                  VALIDATION MODIFIERS
                              /////////////////////////////////////////////////////////////*/
                              modifier validateLien(Lien calldata lien, uint256 lienId) {
                                  if (!_validateLien(lien, lienId)) {
                                      revert InvalidLien();
                                  }
                                  _;
                              }
                              modifier lienIsActive(Lien calldata lien) {
                                  if (_lienIsDefaulted(lien)) {
                                      revert LienIsDefaulted();
                                  }
                                  _;
                              }
                              modifier auctionIsActive(Lien calldata lien) {
                                  if (!_auctionIsActive(lien)) {
                                      revert AuctionIsNotActive();
                                  }
                                  _;
                              }
                              function _validateLien(Lien calldata lien, uint256 lienId) internal view returns (bool) {
                                  return liens[lienId] == keccak256(abi.encode(lien));
                              }
                              function _lienIsDefaulted(Lien calldata lien) internal view returns (bool) {
                                  return
                                      lien.auctionStartBlock != 0 &&
                                      lien.auctionStartBlock + lien.auctionDuration < block.number;
                              }
                              function _auctionIsActive(Lien calldata lien) internal view returns (bool) {
                                  return
                                      lien.auctionStartBlock != 0 &&
                                      lien.auctionStartBlock + lien.auctionDuration >= block.number;
                              }
                          }
                          // SPDX-License-Identifier: MIT
                          // OpenZeppelin Contracts (last updated v4.8.0) (proxy/utils/UUPSUpgradeable.sol)
                          pragma solidity ^0.8.0;
                          import "../../interfaces/draft-IERC1822Upgradeable.sol";
                          import "../ERC1967/ERC1967UpgradeUpgradeable.sol";
                          import "./Initializable.sol";
                          /**
                           * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an
                           * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.
                           *
                           * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is
                           * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing
                           * `UUPSUpgradeable` with a custom implementation of upgrades.
                           *
                           * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.
                           *
                           * _Available since v4.1._
                           */
                          abstract contract UUPSUpgradeable is Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable {
                              function __UUPSUpgradeable_init() internal onlyInitializing {
                              }
                              function __UUPSUpgradeable_init_unchained() internal onlyInitializing {
                              }
                              /// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment
                              address private immutable __self = address(this);
                              /**
                               * @dev Check that the execution is being performed through a delegatecall call and that the execution context is
                               * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case
                               * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a
                               * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to
                               * fail.
                               */
                              modifier onlyProxy() {
                                  require(address(this) != __self, "Function must be called through delegatecall");
                                  require(_getImplementation() == __self, "Function must be called through active proxy");
                                  _;
                              }
                              /**
                               * @dev Check that the execution is not being performed through a delegate call. This allows a function to be
                               * callable on the implementing contract but not through proxies.
                               */
                              modifier notDelegated() {
                                  require(address(this) == __self, "UUPSUpgradeable: must not be called through delegatecall");
                                  _;
                              }
                              /**
                               * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the
                               * implementation. It is used to validate the implementation's compatibility when performing an upgrade.
                               *
                               * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
                               * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
                               * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.
                               */
                              function proxiableUUID() external view virtual override notDelegated returns (bytes32) {
                                  return _IMPLEMENTATION_SLOT;
                              }
                              /**
                               * @dev Upgrade the implementation of the proxy to `newImplementation`.
                               *
                               * Calls {_authorizeUpgrade}.
                               *
                               * Emits an {Upgraded} event.
                               */
                              function upgradeTo(address newImplementation) external virtual onlyProxy {
                                  _authorizeUpgrade(newImplementation);
                                  _upgradeToAndCallUUPS(newImplementation, new bytes(0), false);
                              }
                              /**
                               * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call
                               * encoded in `data`.
                               *
                               * Calls {_authorizeUpgrade}.
                               *
                               * Emits an {Upgraded} event.
                               */
                              function upgradeToAndCall(address newImplementation, bytes memory data) external payable virtual onlyProxy {
                                  _authorizeUpgrade(newImplementation);
                                  _upgradeToAndCallUUPS(newImplementation, data, true);
                              }
                              /**
                               * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by
                               * {upgradeTo} and {upgradeToAndCall}.
                               *
                               * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.
                               *
                               * ```solidity
                               * function _authorizeUpgrade(address) internal override onlyOwner {}
                               * ```
                               */
                              function _authorizeUpgrade(address newImplementation) internal virtual;
                              /**
                               * @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: BSL 1.1 - Blend (c) Non Fungible Trading Ltd.
                          pragma solidity 0.8.17;
                          import "lib/solmate/src/utils/SignedWadMath.sol";
                          import { InvalidRepayment } from "./lib/Errors.sol";
                          import "./lib/Structs.sol";
                          import "../pool/interfaces/IBlurPool.sol";
                          import { IBlurExchangeV2 as IExchangeV2 } from "../exchangeV2/interfaces/IBlurExchangeV2.sol";
                          import { Order as OrderV1, SignatureVersion, Side } from "../exchangeV1/lib/OrderStructs.sol";
                          import {
                              TakeAskSingle,
                              TakeBidSingle,
                              FeeRate,
                              Taker,
                              Exchange,
                              Order as OrderV2,
                              AssetType
                          } from "../exchangeV2/lib/Structs.sol";
                          interface IExchange {
                              function execute(Input calldata sell, Input calldata buy) external payable;
                          }
                          library Helpers {
                              int256 private constant _YEAR_WAD = 365 days * 1e18;
                              uint256 private constant _LIQUIDATION_THRESHOLD = 100_000;
                              uint256 private constant _BASIS_POINTS = 10_000;
                              error InvalidExecution();
                              /**
                               * @dev Computes the current debt of a borrow given the last time it was touched and the last computed debt.
                               * @param amount Principal in ETH
                               * @param startTime Start time of the loan
                               * @param rate Interest rate (in bips)
                               * @dev Formula: https://www.desmos.com/calculator/l6omp0rwnh
                               */
                              function computeCurrentDebt(
                                  uint256 amount,
                                  uint256 rate,
                                  uint256 startTime
                              ) public view returns (uint256) {
                                  uint256 loanTime = block.timestamp - startTime;
                                  int256 yearsWad = wadDiv(int256(loanTime) * 1e18, _YEAR_WAD);
                                  return uint256(wadMul(int256(amount), wadExp(wadMul(yearsWad, bipsToSignedWads(rate)))));
                              }
                              /**
                               * @dev Calculates the current maximum interest rate a specific refinancing
                               * auction could settle at currently given the auction's start block and duration.
                               * @param startBlock The block the auction started at
                               * @param oldRate Previous interest rate (in bips)
                               * @dev Formula: https://www.desmos.com/calculator/urasr71dhb
                               */
                              function calcRefinancingAuctionRate(
                                  uint256 startBlock,
                                  uint256 auctionDuration,
                                  uint256 oldRate
                              ) public view returns (uint256) {
                                  uint256 currentAuctionBlock = block.number - startBlock;
                                  int256 oldRateWads = bipsToSignedWads(oldRate);
                                  uint256 auctionT1 = auctionDuration / 5;
                                  uint256 auctionT2 = (4 * auctionDuration) / 5;
                                  int256 maxRateWads;
                                  {
                                      int256 aInverse = -bipsToSignedWads(15000);
                                      int256 b = 2;
                                      int256 maxMinRateWads = bipsToSignedWads(500);
                                      if (oldRateWads < -((b * aInverse) / 2)) {
                                          maxRateWads = maxMinRateWads + (oldRateWads ** 2) / aInverse + b * oldRateWads;
                                      } else {
                                          maxRateWads = maxMinRateWads - ((b ** 2) * aInverse) / 4;
                                      }
                                  }
                                  int256 startSlope = maxRateWads / int256(auctionT1); // wad-bips per block
                                  int256 middleSlope = bipsToSignedWads(9000) / int256((3 * auctionDuration) / 5) + 1; // wad-bips per block (add one to account for rounding)
                                  int256 middleB = maxRateWads - int256(auctionT1) * middleSlope;
                                  if (currentAuctionBlock < auctionT1) {
                                      return signedWadsToBips(startSlope * int256(currentAuctionBlock));
                                  } else if (currentAuctionBlock < auctionT2) {
                                      return signedWadsToBips(middleSlope * int256(currentAuctionBlock) + middleB);
                                  } else if (currentAuctionBlock < auctionDuration) {
                                      int256 endSlope;
                                      int256 endB;
                                      {
                                          endSlope =
                                              (bipsToSignedWads(_LIQUIDATION_THRESHOLD) -
                                                  ((int256(auctionT2) * middleSlope) + middleB)) /
                                              int256(auctionDuration - auctionT2); // wad-bips per block
                                          endB =
                                              bipsToSignedWads(_LIQUIDATION_THRESHOLD) -
                                              int256(auctionDuration) *
                                              endSlope;
                                      }
                                      return signedWadsToBips(endSlope * int256(currentAuctionBlock) + endB);
                                  } else {
                                      return _LIQUIDATION_THRESHOLD;
                                  }
                              }
                              /**
                               * @dev Converts an integer bips value to a signed wad value.
                               */
                              function bipsToSignedWads(uint256 bips) public pure returns (int256) {
                                  return int256((bips * 1e18) / _BASIS_POINTS);
                              }
                              /**
                               * @dev Converts a signed wad value to an integer bips value.
                               */
                              function signedWadsToBips(int256 wads) public pure returns (uint256) {
                                  return uint256((wads * int256(_BASIS_POINTS)) / 1e18);
                              }
                              function executeTakeBid(
                                  Lien calldata lien,
                                  uint256 lienId,
                                  ExecutionV1 calldata execution,
                                  uint256 debt,
                                  IBlurPool pool,
                                  IExchange exchange,
                                  address delegate,
                                  address matchingPolicy
                              ) external {
                                  /* Create sell side order from Blend. */
                                  OrderV1 memory sellOrder = OrderV1({
                                      trader: address(this),
                                      side: Side.Sell,
                                      matchingPolicy: matchingPolicy,
                                      collection: address(lien.collection),
                                      tokenId: lien.tokenId,
                                      amount: 1,
                                      paymentToken: address(pool),
                                      price: execution.makerOrder.order.price,
                                      listingTime: execution.makerOrder.order.listingTime + 1, // listingTime determines maker/taker
                                      expirationTime: type(uint256).max,
                                      fees: new Fee[](0),
                                      salt: lienId, // prevent reused order hash
                                      extraParams: "\\x01" // require oracle signature
                                  });
                                  Input memory sell = Input({
                                      order: sellOrder,
                                      v: 0,
                                      r: bytes32(0),
                                      s: bytes32(0),
                                      extraSignature: execution.extraSignature,
                                      signatureVersion: SignatureVersion.Single,
                                      blockNumber: execution.blockNumber
                                  });
                                  /* Execute marketplace order. */
                                  uint256 balanceBefore = pool.balanceOf(address(this));
                                  lien.collection.approve(delegate, lien.tokenId);
                                  exchange.execute(sell, execution.makerOrder);
                                  /* Determine the funds received from the sale (after fees). */
                                  uint256 amountReceivedFromSale = pool.balanceOf(address(this)) - balanceBefore;
                                  if (amountReceivedFromSale < debt) {
                                      revert InvalidRepayment();
                                  }
                                  /* Repay lender. */
                                  pool.transferFrom(address(this), lien.lender, debt);
                                  /* Send surplus to borrower. */
                                  unchecked {
                                      pool.transferFrom(address(this), lien.borrower, amountReceivedFromSale - debt);
                                  }
                              }
                              function executeTakeAskV2(
                                  LoanOffer calldata offer, 
                                  AskExecutionV2 calldata execution,
                                  uint256 loanAmount,
                                  uint256 collateralTokenId,
                                  uint256 price,
                                  IBlurPool pool,
                                  IExchangeV2 exchangeV2
                              ) external {
                                  OrderV2 calldata order = execution.order;
                                  if (address(offer.collection) != order.collection || order.assetType != AssetType.ERC721) {
                                      revert InvalidExecution();
                                  }
                                  /* Transfer funds. */
                                  /* Need to retrieve the ETH to fund the marketplace execution. */
                                  if (loanAmount < price) {
                                      /* Take funds from lender. */
                                      pool.withdrawFrom(offer.lender, address(this), loanAmount);
                                      /* Supplement difference from borrower. */
                                      unchecked {
                                          pool.withdrawFrom(msg.sender, address(this), price - loanAmount);
                                      }
                                  } else {
                                      /* Take funds from lender. */
                                      pool.withdrawFrom(offer.lender, address(this), price);
                                      /* Send surplus to borrower. */
                                      unchecked {
                                          pool.transferFrom(offer.lender, msg.sender, loanAmount - price);
                                      }
                                  }
                                  TakeAskSingle memory execute = TakeAskSingle({
                                      order: execution.order,
                                      exchange: Exchange({
                                          index: 0,
                                          proof: execution.proof,
                                          listing: Listing({
                                              index: execution.listing.index,
                                              tokenId: collateralTokenId,
                                              amount: 1,
                                              price: price
                                          }),
                                          taker: Taker({ tokenId: collateralTokenId, amount: 1 })
                                      }),
                                      takerFee: FeeRate(address(0), 0),
                                      signature: execution.signature,
                                      tokenRecipient: address(this)
                                  });
                                  exchangeV2.takeAskSingle{ value: price }(execute, execution.oracleSignature);
                              }
                              function executeTakeAsk(
                                  LoanOffer calldata offer,
                                  ExecutionV1 calldata execution,
                                  uint256 loanAmount,
                                  uint256 collateralTokenId,
                                  uint256 price,
                                  IBlurPool pool,
                                  IExchange exchange,
                                  address matchingPolicy
                              ) external {
                                  /* Transfer funds. */
                                  /* Need to retrieve the ETH to fund the marketplace execution. */
                                  if (loanAmount < price) {
                                      /* Take funds from lender. */
                                      pool.withdrawFrom(offer.lender, address(this), loanAmount);
                                      /* Supplement difference from borrower. */
                                      unchecked {
                                          pool.withdrawFrom(msg.sender, address(this), price - loanAmount);
                                      }
                                  } else {
                                      /* Take funds from lender. */
                                      pool.withdrawFrom(offer.lender, address(this), price);
                                      /* Send surplus to borrower. */
                                      unchecked {
                                          pool.transferFrom(offer.lender, msg.sender, loanAmount - price);
                                      }
                                  }
                                  OrderV1 memory buyOrder = OrderV1({
                                      trader: address(this),
                                      side: Side.Buy,
                                      matchingPolicy: matchingPolicy,
                                      collection: address(offer.collection),
                                      tokenId: collateralTokenId,
                                      amount: 1,
                                      paymentToken: address(0),
                                      price: price,
                                      listingTime: execution.makerOrder.order.listingTime + 1, // listingTime determines maker/taker
                                      expirationTime: type(uint256).max,
                                      fees: new Fee[](0),
                                      salt: uint160(execution.makerOrder.order.trader), // prevent reused order hash
                                      extraParams: "\\x01" // require oracle signature
                                  });
                                  Input memory buy = Input({
                                      order: buyOrder,
                                      v: 0,
                                      r: bytes32(0),
                                      s: bytes32(0),
                                      extraSignature: execution.extraSignature,
                                      signatureVersion: SignatureVersion.Single,
                                      blockNumber: execution.blockNumber
                                  });
                                  /* Execute order using ETH currently in contract. */
                                  exchange.execute{ value: price }(execution.makerOrder, buy);
                              }
                              function executeTakeBidV2(
                                  Lien calldata lien,
                                  BidExecutionV2 calldata execution,
                                  uint256 debt,
                                  IBlurPool pool,
                                  IExchangeV2 exchangeV2,
                                  address delegateV2
                              ) external {
                                  OrderV2 calldata order = execution.order;
                                  if (address(lien.collection) != order.collection || order.assetType != AssetType.ERC721) {
                                      revert InvalidExecution();
                                  }
                                  uint256 balanceBefore = pool.balanceOf(address(this));
                                  TakeBidSingle memory execute = TakeBidSingle({
                                      order: execution.order,
                                      exchange: Exchange({
                                          index: 0,
                                          proof: execution.proof,
                                          listing: execution.listing,
                                          taker: Taker({ tokenId: lien.tokenId, amount: 1 })
                                      }),
                                      takerFee: FeeRate(address(0), 0),
                                      signature: execution.signature
                                  });
                                  /* Execute marketplace order. */
                                  lien.collection.approve(delegateV2, lien.tokenId);
                                  exchangeV2.takeBidSingle(execute, execution.oracleSignature);
                                  /* Determine the funds received from the sale (after fees). */
                                  uint256 amountReceivedFromSale = pool.balanceOf(address(this)) - balanceBefore;
                                  if (amountReceivedFromSale < debt) {
                                      revert InvalidRepayment();
                                  }
                                  /* Repay lender. */
                                  pool.transferFrom(address(this), lien.lender, debt);
                                  /* Send surplus to borrower. */
                                  unchecked {
                                      pool.transferFrom(address(this), lien.borrower, amountReceivedFromSale - debt);
                                  }
                              }
                          }
                          // SPDX-License-Identifier: MIT
                          pragma solidity 0.8.17;
                          import "lib/solmate/src/tokens/ERC721.sol";
                          import { Input, Fee } from "../../exchangeV1/lib/OrderStructs.sol";
                          import { Order as OrderV2, Listing } from "../../exchangeV2/lib/Structs.sol";
                          struct LienPointer {
                              Lien lien;
                              uint256 lienId;
                          }
                          struct SellOffer {
                              address borrower;
                              uint256 lienId;
                              uint256 price;
                              uint256 expirationTime;
                              uint256 salt;
                              address oracle;
                              Fee[] fees;
                          }
                          struct Lien {
                              address lender;
                              address borrower;
                              ERC721 collection;
                              uint256 tokenId;
                              uint256 amount;
                              uint256 startTime;
                              uint256 rate;
                              uint256 auctionStartBlock;
                              uint256 auctionDuration;
                          }
                          struct LoanOffer {
                              address lender;
                              ERC721 collection;
                              uint256 totalAmount;
                              uint256 minAmount;
                              uint256 maxAmount;
                              uint256 auctionDuration;
                              uint256 salt;
                              uint256 expirationTime;
                              uint256 rate;
                              address oracle;
                          }
                          struct LoanInput {
                              LoanOffer offer;
                              bytes signature;
                          }
                          struct SellInput {
                              SellOffer offer;
                              bytes signature;
                          }
                          struct ExecutionV1 {
                              Input makerOrder;
                              bytes extraSignature;
                              uint256 blockNumber;
                          }
                          struct BidExecutionV2 {
                              OrderV2 order;
                              Listing listing;
                              bytes32[] proof;
                              bytes signature;
                              bytes oracleSignature;
                          }
                          struct AskExecutionV2 {
                              OrderV2 order;
                              Listing listing;
                              bytes32[] proof;
                              bytes signature;
                              bytes oracleSignature;
                          }
                          // SPDX-License-Identifier: BSL 1.1 - Blend (c) Non Fungible Trading Ltd.
                          pragma solidity 0.8.17;
                          import "lib/openzeppelin-contracts-upgradeable/contracts/access/Ownable2StepUpgradeable.sol";
                          import "./lib/Signatures.sol";
                          import "./interfaces/IOfferController.sol";
                          abstract contract OfferController is IOfferController, Signatures, Ownable2StepUpgradeable {
                              mapping(address => mapping(uint256 => uint256)) public cancelledOrFulfilled;
                              uint256[50] private _gap;
                              /**
                               * @notice Assert offer validity
                               * @param offerHash Offer hash
                               * @param signer Address of offer signer
                               * @param oracle Address of oracle
                               * @param signature Packed signature array
                               * @param expirationTime Offer expiration time
                               * @param salt Offer salt
                               */
                              function _validateOffer(
                                  bytes32 offerHash,
                                  address signer,
                                  address oracle,
                                  bytes calldata signature,
                                  uint256 expirationTime,
                                  uint256 salt
                              ) internal view {
                                  _verifyOfferAuthorization(offerHash, signer, oracle, signature);
                                  if (expirationTime < block.timestamp) {
                                      revert OfferExpired();
                                  }
                                  if (cancelledOrFulfilled[signer][salt] == 1) {
                                      revert OfferUnavailable();
                                  }
                              }
                              /*/////////////////////////////////////////
                                            CANCEL FUNCTIONS
                              /////////////////////////////////////////*/
                              /**
                               * @notice Cancels offer salt for caller
                               * @param salt Unique offer salt
                               */
                              function cancelOffer(uint256 salt) external {
                                  _cancelOffer(msg.sender, salt);
                              }
                              /**
                               * @notice Cancels offers in bulk for caller
                               * @param salts List of offer salts
                               */
                              function cancelOffers(uint256[] calldata salts) external {
                                  uint256 saltsLength = salts.length;
                                  for (uint256 i; i < saltsLength; ) {
                                      _cancelOffer(msg.sender, salts[i]);
                                      unchecked {
                                          ++i;
                                      }
                                  }
                              }
                              /**
                               * @notice Cancels all offers by incrementing caller nonce
                               */
                              function incrementNonce() external {
                                  _incrementNonce(msg.sender);
                              }
                              /**
                               * @notice Cancel offer by user and salt
                               * @param user Address of user
                               * @param salt Unique offer salt
                               */
                              function _cancelOffer(address user, uint256 salt) private {
                                  cancelledOrFulfilled[user][salt] = 1;
                                  emit OfferCancelled(user, salt);
                              }
                              /**
                               * @notice Cancel all orders by incrementing the user nonce
                               * @param user Address of user
                               */
                              function _incrementNonce(address user) internal {
                                  emit NonceIncremented(user, ++nonces[user]);
                              }
                              /*/////////////////////////////////////////
                                            ADMIN FUNCTIONS
                              /////////////////////////////////////////*/
                              /**
                               * @notice Set approval for an oracle address
                               * @param oracle Address of oracle
                               * @param approved Whether the oracle is approved
                               */
                              function setOracle(address oracle, bool approved) external onlyOwner {
                                  if (approved) {
                                      oracles[oracle] = 1;
                                  } else {
                                      oracles[oracle] = 0;
                                  }
                              }
                              /**
                               * @notice Set the block range expiry of oracle signatures
                               * @param _blockRange Block range
                               */
                              function setBlockRange(uint256 _blockRange) external onlyOwner {
                                  blockRange = _blockRange;
                              }
                          }
                          // SPDX-License-Identifier: MIT
                          pragma solidity ^0.8.0;
                          import "../lib/Structs.sol";
                          import "./IOfferController.sol";
                          interface IBlend is IOfferController {
                              event LoanOfferTaken(
                                  bytes32 offerHash,
                                  uint256 lienId,
                                  address collection,
                                  address lender,
                                  address borrower,
                                  uint256 loanAmount,
                                  uint256 rate,
                                  uint256 tokenId,
                                  uint256 auctionDuration
                              );
                              event Repay(uint256 lienId, address collection);
                              event StartAuction(uint256 lienId, address collection);
                              event Refinance(
                                  uint256 lienId,
                                  address collection,
                                  address newLender,
                                  uint256 newAmount,
                                  uint256 newRate,
                                  uint256 newAuctionDuration
                              );
                              event Seize(uint256 lienId, address collection);
                              event BuyLocked(
                                  uint256 lienId,
                                  address collection,
                                  address buyer,
                                  address seller,
                                  uint256 tokenId
                              );
                              function amountTaken(bytes32 offerHash) external view returns (uint256);
                              function liens(uint256 lienId) external view returns (bytes32);
                              /*//////////////////////////////////////////////////
                                              BORROW FLOWS
                              //////////////////////////////////////////////////*/
                              function borrow(
                                  LoanOffer calldata offer,
                                  bytes calldata signature,
                                  uint256 loanAmount,
                                  uint256 collateralId
                              ) external returns (uint256 lienId);
                              function repay(Lien calldata lien, uint256 lienId) external;
                              /*//////////////////////////////////////////////////
                                              REFINANCING FLOWS
                              //////////////////////////////////////////////////*/
                              function startAuction(Lien calldata lien, uint256 lienId) external;
                              function seize(LienPointer[] calldata lienPointers) external;
                              function refinance(
                                  Lien calldata lien,
                                  uint256 lienId,
                                  LoanOffer calldata offer,
                                  bytes calldata signature
                              ) external;
                              function refinanceAuction(Lien calldata lien, uint256 lienId, uint256 rate) external;
                              function refinanceAuctionByOther(
                                  Lien calldata lien,
                                  uint256 lienId,
                                  LoanOffer calldata offer,
                                  bytes calldata signature
                              ) external;
                              function borrowerRefinance(
                                  Lien calldata lien,
                                  uint256 lienId,
                                  uint256 loanAmount,
                                  LoanOffer calldata offer,
                                  bytes calldata signature
                              ) external;
                              /*//////////////////////////////////////////////////
                                              MARKETPLACE FLOWS
                              //////////////////////////////////////////////////*/
                              function buyToBorrow(
                                  LoanOffer calldata offer,
                                  bytes calldata signature,
                                  uint256 loanAmount,
                                  ExecutionV1 calldata execution
                              ) external returns (uint256 lienId);
                              function buyToBorrowETH(
                                  LoanOffer calldata offer,
                                  bytes calldata signature,
                                  uint256 loanAmount,
                                  ExecutionV1 calldata execution
                              ) external payable returns (uint256 lienId);
                              function buyToBorrowLocked(
                                  Lien calldata lien,
                                  SellInput calldata sellInput,
                                  LoanInput calldata loanInput,
                                  uint256 loanAmount
                              ) external returns (uint256 lienId);
                              function buyToBorrowLockedETH(
                                  Lien calldata lien,
                                  SellInput calldata sellInput,
                                  LoanInput calldata loanInput,
                                  uint256 loanAmount
                              ) external payable returns (uint256 lienId);
                              function buyLocked(
                                  Lien calldata lien,
                                  SellOffer calldata offer,
                                  bytes calldata signature
                              ) external;
                              function buyLockedETH(
                                  Lien calldata lien,
                                  SellOffer calldata offer,
                                  bytes calldata signature
                              ) external payable;
                              function takeBid(Lien calldata lien, uint256 lienId, ExecutionV1 calldata execution) external;
                          }
                          // SPDX-License-Identifier: MIT
                          pragma solidity ^0.8.0;
                          interface IBlurPool {
                              event Transfer(address indexed from, address indexed to, uint256 amount);
                              function initialize() external;
                              function decimals() external pure returns (uint8);
                              function totalSupply() external view returns (uint256);
                              function balanceOf(address user) external view returns (uint256);
                              function deposit() external payable;
                              function deposit(address user) external payable;
                              function withdraw(uint256 amount) external;
                              function withdrawFrom(address from, address to, uint256 amount) external;
                              function transferFrom(address from, address to, uint256 amount) external returns (bool);
                          }
                          // SPDX-License-Identifier: MIT
                          // OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)
                          pragma solidity ^0.8.0;
                          /**
                           * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
                           * proxy whose upgrades are fully controlled by the current implementation.
                           */
                          interface IERC1822ProxiableUpgradeable {
                              /**
                               * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
                               * address.
                               *
                               * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
                               * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
                               * function revert if invoked through a proxy.
                               */
                              function proxiableUUID() external view returns (bytes32);
                          }
                          // SPDX-License-Identifier: MIT
                          // OpenZeppelin Contracts (last updated v4.8.3) (proxy/ERC1967/ERC1967Upgrade.sol)
                          pragma solidity ^0.8.2;
                          import "../beacon/IBeaconUpgradeable.sol";
                          import "../../interfaces/IERC1967Upgradeable.sol";
                          import "../../interfaces/draft-IERC1822Upgradeable.sol";
                          import "../../utils/AddressUpgradeable.sol";
                          import "../../utils/StorageSlotUpgradeable.sol";
                          import "../utils/Initializable.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 ERC1967UpgradeUpgradeable is Initializable, IERC1967Upgradeable {
                              function __ERC1967Upgrade_init() internal onlyInitializing {
                              }
                              function __ERC1967Upgrade_init_unchained() internal onlyInitializing {
                              }
                              // 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 Returns the current implementation address.
                               */
                              function _getImplementation() internal view returns (address) {
                                  return StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value;
                              }
                              /**
                               * @dev Stores a new address in the EIP1967 implementation slot.
                               */
                              function _setImplementation(address newImplementation) private {
                                  require(AddressUpgradeable.isContract(newImplementation), "ERC1967: new implementation is not a contract");
                                  StorageSlotUpgradeable.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 {
                                  _upgradeTo(newImplementation);
                                  if (data.length > 0 || forceCall) {
                                      _functionDelegateCall(newImplementation, data);
                                  }
                              }
                              /**
                               * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
                               *
                               * Emits an {Upgraded} event.
                               */
                              function _upgradeToAndCallUUPS(
                                  address newImplementation,
                                  bytes memory data,
                                  bool forceCall
                              ) internal {
                                  // Upgrades from old implementations will perform a rollback test. This test requires the new
                                  // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
                                  // this special case will break upgrade paths from old UUPS implementation to new ones.
                                  if (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) {
                                      _setImplementation(newImplementation);
                                  } else {
                                      try IERC1822ProxiableUpgradeable(newImplementation).proxiableUUID() returns (bytes32 slot) {
                                          require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
                                      } catch {
                                          revert("ERC1967Upgrade: new implementation is not UUPS");
                                      }
                                      _upgradeToAndCall(newImplementation, data, forceCall);
                                  }
                              }
                              /**
                               * @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 Returns the current admin.
                               */
                              function _getAdmin() internal view returns (address) {
                                  return StorageSlotUpgradeable.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");
                                  StorageSlotUpgradeable.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 Returns the current beacon.
                               */
                              function _getBeacon() internal view returns (address) {
                                  return StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value;
                              }
                              /**
                               * @dev Stores a new beacon in the EIP1967 beacon slot.
                               */
                              function _setBeacon(address newBeacon) private {
                                  require(AddressUpgradeable.isContract(newBeacon), "ERC1967: new beacon is not a contract");
                                  require(
                                      AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()),
                                      "ERC1967: beacon implementation is not a contract"
                                  );
                                  StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value = newBeacon;
                              }
                              /**
                               * @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) {
                                      _functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data);
                                  }
                              }
                              /**
                               * @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) private returns (bytes memory) {
                                  require(AddressUpgradeable.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 AddressUpgradeable.verifyCallResult(success, returndata, "Address: low-level delegate call failed");
                              }
                              /**
                               * @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.1) (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 Returns the highest version that has been initialized. See {reinitializer}.
                               */
                              function _getInitializedVersion() internal view returns (uint8) {
                                  return _initialized;
                              }
                              /**
                               * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
                               */
                              function _isInitializing() internal view returns (bool) {
                                  return _initializing;
                              }
                          }
                          // SPDX-License-Identifier: MIT
                          // OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)
                          pragma solidity ^0.8.0;
                          /**
                           * @dev This is the interface that {BeaconProxy} expects of its beacon.
                           */
                          interface IBeaconUpgradeable {
                              /**
                               * @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
                          // OpenZeppelin Contracts (last updated v4.8.3) (interfaces/IERC1967.sol)
                          pragma solidity ^0.8.0;
                          /**
                           * @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC.
                           *
                           * _Available since v4.9._
                           */
                          interface IERC1967Upgradeable {
                              /**
                               * @dev Emitted when the implementation is upgraded.
                               */
                              event Upgraded(address indexed implementation);
                              /**
                               * @dev Emitted when the admin account has changed.
                               */
                              event AdminChanged(address previousAdmin, address newAdmin);
                              /**
                               * @dev Emitted when the beacon is changed.
                               */
                              event BeaconUpgraded(address indexed beacon);
                          }
                          // 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 (last updated v4.7.0) (utils/StorageSlot.sol)
                          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 StorageSlotUpgradeable {
                              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) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r.slot := slot
                                  }
                              }
                              /**
                               * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
                               */
                              function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r.slot := slot
                                  }
                              }
                              /**
                               * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
                               */
                              function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r.slot := slot
                                  }
                              }
                              /**
                               * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
                               */
                              function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r.slot := slot
                                  }
                              }
                          }
                          // SPDX-License-Identifier: MIT
                          pragma solidity >=0.8.0;
                          /// @notice Signed 18 decimal fixed point (wad) arithmetic library.
                          /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SignedWadMath.sol)
                          /// @author Modified from Remco Bloemen (https://xn--2-umb.com/22/exp-ln/index.html)
                          /// @dev Will not revert on overflow, only use where overflow is not possible.
                          function toWadUnsafe(uint256 x) pure returns (int256 r) {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  // Multiply x by 1e18.
                                  r := mul(x, 1000000000000000000)
                              }
                          }
                          /// @dev Takes an integer amount of seconds and converts it to a wad amount of days.
                          /// @dev Will not revert on overflow, only use where overflow is not possible.
                          /// @dev Not meant for negative second amounts, it assumes x is positive.
                          function toDaysWadUnsafe(uint256 x) pure returns (int256 r) {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  // Multiply x by 1e18 and then divide it by 86400.
                                  r := div(mul(x, 1000000000000000000), 86400)
                              }
                          }
                          /// @dev Takes a wad amount of days and converts it to an integer amount of seconds.
                          /// @dev Will not revert on overflow, only use where overflow is not possible.
                          /// @dev Not meant for negative day amounts, it assumes x is positive.
                          function fromDaysWadUnsafe(int256 x) pure returns (uint256 r) {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  // Multiply x by 86400 and then divide it by 1e18.
                                  r := div(mul(x, 86400), 1000000000000000000)
                              }
                          }
                          /// @dev Will not revert on overflow, only use where overflow is not possible.
                          function unsafeWadMul(int256 x, int256 y) pure returns (int256 r) {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  // Multiply x by y and divide by 1e18.
                                  r := sdiv(mul(x, y), 1000000000000000000)
                              }
                          }
                          /// @dev Will return 0 instead of reverting if y is zero and will
                          /// not revert on overflow, only use where overflow is not possible.
                          function unsafeWadDiv(int256 x, int256 y) pure returns (int256 r) {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  // Multiply x by 1e18 and divide it by y.
                                  r := sdiv(mul(x, 1000000000000000000), y)
                              }
                          }
                          function wadMul(int256 x, int256 y) pure returns (int256 r) {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  // Store x * y in r for now.
                                  r := mul(x, y)
                                  // Equivalent to require(x == 0 || (x * y) / x == y)
                                  if iszero(or(iszero(x), eq(sdiv(r, x), y))) {
                                      revert(0, 0)
                                  }
                                  // Scale the result down by 1e18.
                                  r := sdiv(r, 1000000000000000000)
                              }
                          }
                          function wadDiv(int256 x, int256 y) pure returns (int256 r) {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  // Store x * 1e18 in r for now.
                                  r := mul(x, 1000000000000000000)
                                  // Equivalent to require(y != 0 && ((x * 1e18) / 1e18 == x))
                                  if iszero(and(iszero(iszero(y)), eq(sdiv(r, 1000000000000000000), x))) {
                                      revert(0, 0)
                                  }
                                  // Divide r by y.
                                  r := sdiv(r, y)
                              }
                          }
                          /// @dev Will not work with negative bases, only use when x is positive.
                          function wadPow(int256 x, int256 y) pure returns (int256) {
                              // Equivalent to x to the power of y because x ** y = (e ** ln(x)) ** y = e ** (ln(x) * y)
                              return wadExp((wadLn(x) * y) / 1e18); // Using ln(x) means x must be greater than 0.
                          }
                          function wadExp(int256 x) pure returns (int256 r) {
                              unchecked {
                                  // When the result is < 0.5 we return zero. This happens when
                                  // x <= floor(log(0.5e18) * 1e18) ~ -42e18
                                  if (x <= -42139678854452767551) return 0;
                                  // When the result is > (2**255 - 1) / 1e18 we can not represent it as an
                                  // int. This happens when x >= floor(log((2**255 - 1) / 1e18) * 1e18) ~ 135.
                                  if (x >= 135305999368893231589) revert("EXP_OVERFLOW");
                                  // x is now in the range (-42, 136) * 1e18. Convert to (-42, 136) * 2**96
                                  // for more intermediate precision and a binary basis. This base conversion
                                  // is a multiplication by 1e18 / 2**96 = 5**18 / 2**78.
                                  x = (x << 78) / 5**18;
                                  // Reduce range of x to (-½ ln 2, ½ ln 2) * 2**96 by factoring out powers
                                  // of two such that exp(x) = exp(x') * 2**k, where k is an integer.
                                  // Solving this gives k = round(x / log(2)) and x' = x - k * log(2).
                                  int256 k = ((x << 96) / 54916777467707473351141471128 + 2**95) >> 96;
                                  x = x - k * 54916777467707473351141471128;
                                  // k is in the range [-61, 195].
                                  // Evaluate using a (6, 7)-term rational approximation.
                                  // p is made monic, we'll multiply by a scale factor later.
                                  int256 y = x + 1346386616545796478920950773328;
                                  y = ((y * x) >> 96) + 57155421227552351082224309758442;
                                  int256 p = y + x - 94201549194550492254356042504812;
                                  p = ((p * y) >> 96) + 28719021644029726153956944680412240;
                                  p = p * x + (4385272521454847904659076985693276 << 96);
                                  // We leave p in 2**192 basis so we don't need to scale it back up for the division.
                                  int256 q = x - 2855989394907223263936484059900;
                                  q = ((q * x) >> 96) + 50020603652535783019961831881945;
                                  q = ((q * x) >> 96) - 533845033583426703283633433725380;
                                  q = ((q * x) >> 96) + 3604857256930695427073651918091429;
                                  q = ((q * x) >> 96) - 14423608567350463180887372962807573;
                                  q = ((q * x) >> 96) + 26449188498355588339934803723976023;
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      // Div in assembly because solidity adds a zero check despite the unchecked.
                                      // The q polynomial won't have zeros in the domain as all its roots are complex.
                                      // No scaling is necessary because p is already 2**96 too large.
                                      r := sdiv(p, q)
                                  }
                                  // r should be in the range (0.09, 0.25) * 2**96.
                                  // We now need to multiply r by:
                                  // * the scale factor s = ~6.031367120.
                                  // * the 2**k factor from the range reduction.
                                  // * the 1e18 / 2**96 factor for base conversion.
                                  // We do this all at once, with an intermediate result in 2**213
                                  // basis, so the final right shift is always by a positive amount.
                                  r = int256((uint256(r) * 3822833074963236453042738258902158003155416615667) >> uint256(195 - k));
                              }
                          }
                          function wadLn(int256 x) pure returns (int256 r) {
                              unchecked {
                                  require(x > 0, "UNDEFINED");
                                  // We want to convert x from 10**18 fixed point to 2**96 fixed point.
                                  // We do this by multiplying by 2**96 / 10**18. But since
                                  // ln(x * C) = ln(x) + ln(C), we can simply do nothing here
                                  // and add ln(2**96 / 10**18) at the end.
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
                                      r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
                                      r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
                                      r := or(r, shl(4, lt(0xffff, shr(r, x))))
                                      r := or(r, shl(3, lt(0xff, shr(r, x))))
                                      r := or(r, shl(2, lt(0xf, shr(r, x))))
                                      r := or(r, shl(1, lt(0x3, shr(r, x))))
                                      r := or(r, lt(0x1, shr(r, x)))
                                  }
                                  // Reduce range of x to (1, 2) * 2**96
                                  // ln(2^k * x) = k * ln(2) + ln(x)
                                  int256 k = r - 96;
                                  x <<= uint256(159 - k);
                                  x = int256(uint256(x) >> 159);
                                  // Evaluate using a (8, 8)-term rational approximation.
                                  // p is made monic, we will multiply by a scale factor later.
                                  int256 p = x + 3273285459638523848632254066296;
                                  p = ((p * x) >> 96) + 24828157081833163892658089445524;
                                  p = ((p * x) >> 96) + 43456485725739037958740375743393;
                                  p = ((p * x) >> 96) - 11111509109440967052023855526967;
                                  p = ((p * x) >> 96) - 45023709667254063763336534515857;
                                  p = ((p * x) >> 96) - 14706773417378608786704636184526;
                                  p = p * x - (795164235651350426258249787498 << 96);
                                  // We leave p in 2**192 basis so we don't need to scale it back up for the division.
                                  // q is monic by convention.
                                  int256 q = x + 5573035233440673466300451813936;
                                  q = ((q * x) >> 96) + 71694874799317883764090561454958;
                                  q = ((q * x) >> 96) + 283447036172924575727196451306956;
                                  q = ((q * x) >> 96) + 401686690394027663651624208769553;
                                  q = ((q * x) >> 96) + 204048457590392012362485061816622;
                                  q = ((q * x) >> 96) + 31853899698501571402653359427138;
                                  q = ((q * x) >> 96) + 909429971244387300277376558375;
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      // Div in assembly because solidity adds a zero check despite the unchecked.
                                      // The q polynomial is known not to have zeros in the domain.
                                      // No scaling required because p is already 2**96 too large.
                                      r := sdiv(p, q)
                                  }
                                  // r is in the range (0, 0.125) * 2**96
                                  // Finalization, we need to:
                                  // * multiply by the scale factor s = 5.549…
                                  // * add ln(2**96 / 10**18)
                                  // * add k * ln(2)
                                  // * multiply by 10**18 / 2**96 = 5**18 >> 78
                                  // mul s * 5e18 * 2**96, base is now 5**18 * 2**192
                                  r *= 1677202110996718588342820967067443963516166;
                                  // add ln(2) * k * 5e18 * 2**192
                                  r += 16597577552685614221487285958193947469193820559219878177908093499208371 * k;
                                  // add ln(2**96 / 10**18) * 5e18 * 2**192
                                  r += 600920179829731861736702779321621459595472258049074101567377883020018308;
                                  // base conversion: mul 2**18 / 2**192
                                  r >>= 174;
                              }
                          }
                          /// @dev Will return 0 instead of reverting if y is zero.
                          function unsafeDiv(int256 x, int256 y) pure returns (int256 r) {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  // Divide x by y.
                                  r := sdiv(x, y)
                              }
                          }
                          // SPDX-License-Identifier: BSL 1.1 - Blend (c) Non Fungible Trading Ltd.
                          pragma solidity 0.8.17;
                          // Blend
                          error Unauthorized();
                          error InvalidLoan();
                          error InvalidLien();
                          error InsufficientOffer();
                          error InvalidRepayment();
                          error LienIsDefaulted();
                          error LienNotDefaulted();
                          error AuctionIsActive();
                          error AuctionIsNotActive();
                          error InvalidRefinance();
                          error RateTooHigh();
                          error FeesTooHigh();
                          error CollectionsDoNotMatch();
                          error InvalidAuctionDuration();
                          // OfferController
                          error OfferExpired();
                          error OfferUnavailable();
                          // Signatures
                          error UnauthorizedOracle();
                          error SignatureExpired();
                          error InvalidSignature();
                          error InvalidVParameter();
                          // SPDX-License-Identifier: MIT
                          pragma solidity 0.8.17;
                          import {
                              TakeAsk,
                              TakeBid,
                              TakeAskSingle,
                              TakeBidSingle,
                              Order,
                              Exchange,
                              Fees,
                              FeeRate,
                              AssetType,
                              OrderType,
                              Transfer,
                              FungibleTransfers,
                              StateUpdate,
                              Cancel,
                              Listing
                          } from "../lib/Structs.sol";
                          interface IBlurExchangeV2 {
                              error InsufficientFunds();
                              error TokenTransferFailed();
                              error InvalidOrder();
                              error ProtocolFeeTooHigh();
                              event NewProtocolFee(address indexed recipient, uint16 indexed rate);
                              event NewGovernor(address indexed governor);
                              event NewBlockRange(uint256 blockRange);
                              event CancelTrade(address indexed user, bytes32 hash, uint256 index, uint256 amount);
                              event NonceIncremented(address indexed user, uint256 newNonce);
                              event SetOracle(address indexed user, bool approved);
                              function initialize() external;
                              function setProtocolFee(address recipient, uint16 rate) external;
                              function setGovernor(address _governor) external;
                              function setOracle(address oracle, bool approved) external;
                              function setBlockRange(uint256 _blockRange) external;
                              function cancelTrades(Cancel[] memory cancels) external;
                              function incrementNonce() external;
                              /*//////////////////////////////////////////////////////////////
                                                    EXECUTION WRAPPERS
                              //////////////////////////////////////////////////////////////*/
                              function takeAsk(TakeAsk memory inputs, bytes calldata oracleSignature) external payable;
                              function takeBid(TakeBid memory inputs, bytes calldata oracleSignature) external;
                              function takeAskSingle(TakeAskSingle memory inputs, bytes calldata oracleSignature) external payable;
                              function takeBidSingle(TakeBidSingle memory inputs, bytes calldata oracleSignature) external;
                              /*//////////////////////////////////////////////////////////////
                                                  EXECUTION POOL WRAPPERS
                              //////////////////////////////////////////////////////////////*/
                              function takeAskSinglePool(
                                  TakeAskSingle memory inputs,
                                  bytes calldata oracleSignature,
                                  uint256 amountToWithdraw
                              ) external payable;
                              function takeAskPool(
                                  TakeAsk memory inputs,
                                  bytes calldata oracleSignature,
                                  uint256 amountToWithdraw
                              ) external payable;
                          }
                          // SPDX-License-Identifier: MIT
                          pragma solidity 0.8.17;
                          enum Side { Buy, Sell }
                          enum SignatureVersion { Single, Bulk }
                          enum AssetType { ERC721, ERC1155 }
                          struct Fee {
                              uint16 rate;
                              address payable recipient;
                          }
                          struct Order {
                              address trader;
                              Side side;
                              address matchingPolicy;
                              address collection;
                              uint256 tokenId;
                              uint256 amount;
                              address paymentToken;
                              uint256 price;
                              uint256 listingTime;
                              /* Order expiration timestamp - 0 for oracle cancellations. */
                              uint256 expirationTime;
                              Fee[] fees;
                              uint256 salt;
                              bytes extraParams;
                          }
                          struct Input {
                              Order order;
                              uint8 v;
                              bytes32 r;
                              bytes32 s;
                              bytes extraSignature;
                              SignatureVersion signatureVersion;
                              uint256 blockNumber;
                          }
                          struct Execution {
                            Input sell;
                            Input buy;
                          }
                          // SPDX-License-Identifier: MIT
                          pragma solidity ^0.8.17;
                          struct TakeAsk {
                              Order[] orders;
                              Exchange[] exchanges;
                              FeeRate takerFee;
                              bytes signatures;
                              address tokenRecipient;
                          }
                          struct TakeAskSingle {
                              Order order;
                              Exchange exchange;
                              FeeRate takerFee;
                              bytes signature;
                              address tokenRecipient;
                          }
                          struct TakeBid {
                              Order[] orders;
                              Exchange[] exchanges;
                              FeeRate takerFee;
                              bytes signatures;
                          }
                          struct TakeBidSingle {
                              Order order;
                              Exchange exchange;
                              FeeRate takerFee;
                              bytes signature;
                          }
                          enum AssetType {
                              ERC721,
                              ERC1155
                          }
                          enum OrderType {
                              ASK,
                              BID
                          }
                          struct Exchange { // Size: 0x80
                              uint256 index; // 0x00
                              bytes32[] proof; // 0x20
                              Listing listing; // 0x40
                              Taker taker; // 0x60
                          }
                          struct Listing { // Size: 0x80
                              uint256 index; // 0x00
                              uint256 tokenId; // 0x20
                              uint256 amount; // 0x40
                              uint256 price; // 0x60
                          }
                          struct Taker { // Size: 0x40
                              uint256 tokenId; // 0x00
                              uint256 amount; // 0x20
                          }
                          struct Order { // Size: 0x100
                              address trader; // 0x00
                              address collection; // 0x20
                              bytes32 listingsRoot; // 0x40
                              uint256 numberOfListings; // 0x60
                              uint256 expirationTime; // 0x80
                              AssetType assetType; // 0xa0
                              FeeRate makerFee; // 0xc0
                              uint256 salt; // 0xe0
                          }
                          /*
                          Reference only; struct is composed manually using calldata formatting in execution
                          struct ExecutionBatch { // Size: 0x80
                              address taker; // 0x00
                              OrderType orderType; // 0x20
                              Transfer[] transfers; // 0x40
                              uint256 length; // 0x60
                          }
                          */
                          struct Transfer { // Size: 0xa0
                              address trader; // 0x00
                              uint256 id; // 0x20
                              uint256 amount; // 0x40
                              address collection; // 0x60
                              AssetType assetType; // 0x80
                          }
                          struct FungibleTransfers {
                              uint256 totalProtocolFee;
                              uint256 totalSellerTransfer;
                              uint256 totalTakerFee;
                              uint256 feeRecipientId;
                              uint256 makerId;
                              address[] feeRecipients;
                              address[] makers;
                              uint256[] makerTransfers;
                              uint256[] feeTransfers;
                              AtomicExecution[] executions;
                          }
                          struct AtomicExecution { // Size: 0xe0
                              uint256 makerId; // 0x00
                              uint256 sellerAmount; // 0x20
                              uint256 makerFeeRecipientId; // 0x40
                              uint256 makerFeeAmount; // 0x60
                              uint256 takerFeeAmount; // 0x80
                              uint256 protocolFeeAmount; // 0xa0
                              StateUpdate stateUpdate; // 0xc0
                          }
                          struct StateUpdate { // Size: 0xa0
                              address trader; // 0x00
                              bytes32 hash; // 0x20
                              uint256 index; // 0x40
                              uint256 value; // 0x60
                              uint256 maxAmount; // 0x80
                          }
                          struct Fees { // Size: 0x40
                              FeeRate protocolFee; // 0x00
                              FeeRate takerFee; // 0x20
                          }
                          struct FeeRate { // Size: 0x40
                              address recipient; // 0x00
                              uint16 rate; // 0x20
                          }
                          struct Cancel {
                              bytes32 hash;
                              uint256 index;
                              uint256 amount;
                          }
                          // SPDX-License-Identifier: AGPL-3.0-only
                          pragma solidity >=0.8.0;
                          /// @notice Modern, minimalist, and gas efficient ERC-721 implementation.
                          /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC721.sol)
                          abstract contract ERC721 {
                              /*//////////////////////////////////////////////////////////////
                                                           EVENTS
                              //////////////////////////////////////////////////////////////*/
                              event Transfer(address indexed from, address indexed to, uint256 indexed id);
                              event Approval(address indexed owner, address indexed spender, uint256 indexed id);
                              event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
                              /*//////////////////////////////////////////////////////////////
                                                   METADATA STORAGE/LOGIC
                              //////////////////////////////////////////////////////////////*/
                              string public name;
                              string public symbol;
                              function tokenURI(uint256 id) public view virtual returns (string memory);
                              /*//////////////////////////////////////////////////////////////
                                                ERC721 BALANCE/OWNER STORAGE
                              //////////////////////////////////////////////////////////////*/
                              mapping(uint256 => address) internal _ownerOf;
                              mapping(address => uint256) internal _balanceOf;
                              function ownerOf(uint256 id) public view virtual returns (address owner) {
                                  require((owner = _ownerOf[id]) != address(0), "NOT_MINTED");
                              }
                              function balanceOf(address owner) public view virtual returns (uint256) {
                                  require(owner != address(0), "ZERO_ADDRESS");
                                  return _balanceOf[owner];
                              }
                              /*//////////////////////////////////////////////////////////////
                                                   ERC721 APPROVAL STORAGE
                              //////////////////////////////////////////////////////////////*/
                              mapping(uint256 => address) public getApproved;
                              mapping(address => mapping(address => bool)) public isApprovedForAll;
                              /*//////////////////////////////////////////////////////////////
                                                         CONSTRUCTOR
                              //////////////////////////////////////////////////////////////*/
                              constructor(string memory _name, string memory _symbol) {
                                  name = _name;
                                  symbol = _symbol;
                              }
                              /*//////////////////////////////////////////////////////////////
                                                        ERC721 LOGIC
                              //////////////////////////////////////////////////////////////*/
                              function approve(address spender, uint256 id) public virtual {
                                  address owner = _ownerOf[id];
                                  require(msg.sender == owner || isApprovedForAll[owner][msg.sender], "NOT_AUTHORIZED");
                                  getApproved[id] = spender;
                                  emit Approval(owner, spender, id);
                              }
                              function setApprovalForAll(address operator, bool approved) public virtual {
                                  isApprovedForAll[msg.sender][operator] = approved;
                                  emit ApprovalForAll(msg.sender, operator, approved);
                              }
                              function transferFrom(
                                  address from,
                                  address to,
                                  uint256 id
                              ) public virtual {
                                  require(from == _ownerOf[id], "WRONG_FROM");
                                  require(to != address(0), "INVALID_RECIPIENT");
                                  require(
                                      msg.sender == from || isApprovedForAll[from][msg.sender] || msg.sender == getApproved[id],
                                      "NOT_AUTHORIZED"
                                  );
                                  // Underflow of the sender's balance is impossible because we check for
                                  // ownership above and the recipient's balance can't realistically overflow.
                                  unchecked {
                                      _balanceOf[from]--;
                                      _balanceOf[to]++;
                                  }
                                  _ownerOf[id] = to;
                                  delete getApproved[id];
                                  emit Transfer(from, to, id);
                              }
                              function safeTransferFrom(
                                  address from,
                                  address to,
                                  uint256 id
                              ) public virtual {
                                  transferFrom(from, to, id);
                                  require(
                                      to.code.length == 0 ||
                                          ERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, "") ==
                                          ERC721TokenReceiver.onERC721Received.selector,
                                      "UNSAFE_RECIPIENT"
                                  );
                              }
                              function safeTransferFrom(
                                  address from,
                                  address to,
                                  uint256 id,
                                  bytes calldata data
                              ) public virtual {
                                  transferFrom(from, to, id);
                                  require(
                                      to.code.length == 0 ||
                                          ERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, data) ==
                                          ERC721TokenReceiver.onERC721Received.selector,
                                      "UNSAFE_RECIPIENT"
                                  );
                              }
                              /*//////////////////////////////////////////////////////////////
                                                        ERC165 LOGIC
                              //////////////////////////////////////////////////////////////*/
                              function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
                                  return
                                      interfaceId == 0x01ffc9a7 || // ERC165 Interface ID for ERC165
                                      interfaceId == 0x80ac58cd || // ERC165 Interface ID for ERC721
                                      interfaceId == 0x5b5e139f; // ERC165 Interface ID for ERC721Metadata
                              }
                              /*//////////////////////////////////////////////////////////////
                                                  INTERNAL MINT/BURN LOGIC
                              //////////////////////////////////////////////////////////////*/
                              function _mint(address to, uint256 id) internal virtual {
                                  require(to != address(0), "INVALID_RECIPIENT");
                                  require(_ownerOf[id] == address(0), "ALREADY_MINTED");
                                  // Counter overflow is incredibly unrealistic.
                                  unchecked {
                                      _balanceOf[to]++;
                                  }
                                  _ownerOf[id] = to;
                                  emit Transfer(address(0), to, id);
                              }
                              function _burn(uint256 id) internal virtual {
                                  address owner = _ownerOf[id];
                                  require(owner != address(0), "NOT_MINTED");
                                  // Ownership check above ensures no underflow.
                                  unchecked {
                                      _balanceOf[owner]--;
                                  }
                                  delete _ownerOf[id];
                                  delete getApproved[id];
                                  emit Transfer(owner, address(0), id);
                              }
                              /*//////////////////////////////////////////////////////////////
                                                  INTERNAL SAFE MINT LOGIC
                              //////////////////////////////////////////////////////////////*/
                              function _safeMint(address to, uint256 id) internal virtual {
                                  _mint(to, id);
                                  require(
                                      to.code.length == 0 ||
                                          ERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, "") ==
                                          ERC721TokenReceiver.onERC721Received.selector,
                                      "UNSAFE_RECIPIENT"
                                  );
                              }
                              function _safeMint(
                                  address to,
                                  uint256 id,
                                  bytes memory data
                              ) internal virtual {
                                  _mint(to, id);
                                  require(
                                      to.code.length == 0 ||
                                          ERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, data) ==
                                          ERC721TokenReceiver.onERC721Received.selector,
                                      "UNSAFE_RECIPIENT"
                                  );
                              }
                          }
                          /// @notice A generic interface for a contract which properly accepts ERC721 tokens.
                          /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC721.sol)
                          abstract contract ERC721TokenReceiver {
                              function onERC721Received(
                                  address,
                                  address,
                                  uint256,
                                  bytes calldata
                              ) external virtual returns (bytes4) {
                                  return ERC721TokenReceiver.onERC721Received.selector;
                              }
                          }
                          // SPDX-License-Identifier: MIT
                          // OpenZeppelin Contracts (last updated v4.8.0) (access/Ownable2Step.sol)
                          pragma solidity ^0.8.0;
                          import "./OwnableUpgradeable.sol";
                          import "../proxy/utils/Initializable.sol";
                          /**
                           * @dev Contract module which provides 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} and {acceptOwnership}.
                           *
                           * This module is used through inheritance. It will make available all functions
                           * from parent (Ownable).
                           */
                          abstract contract Ownable2StepUpgradeable is Initializable, OwnableUpgradeable {
                              function __Ownable2Step_init() internal onlyInitializing {
                                  __Ownable_init_unchained();
                              }
                              function __Ownable2Step_init_unchained() internal onlyInitializing {
                              }
                              address private _pendingOwner;
                              event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);
                              /**
                               * @dev Returns the address of the pending owner.
                               */
                              function pendingOwner() public view virtual returns (address) {
                                  return _pendingOwner;
                              }
                              /**
                               * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.
                               * Can only be called by the current owner.
                               */
                              function transferOwnership(address newOwner) public virtual override onlyOwner {
                                  _pendingOwner = newOwner;
                                  emit OwnershipTransferStarted(owner(), newOwner);
                              }
                              /**
                               * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.
                               * Internal function without access restriction.
                               */
                              function _transferOwnership(address newOwner) internal virtual override {
                                  delete _pendingOwner;
                                  super._transferOwnership(newOwner);
                              }
                              /**
                               * @dev The new owner accepts the ownership transfer.
                               */
                              function acceptOwnership() external {
                                  address sender = _msgSender();
                                  require(pendingOwner() == sender, "Ownable2Step: caller is not the new owner");
                                  _transferOwnership(sender);
                              }
                              /**
                               * @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: BSL 1.1 - Blend (c) Non Fungible Trading Ltd.
                          pragma solidity 0.8.17;
                          import "./Structs.sol";
                          import "./Errors.sol";
                          import "../interfaces/ISignatures.sol";
                          abstract contract Signatures is ISignatures {
                              bytes32 private immutable _LOAN_OFFER_TYPEHASH;
                              bytes32 private immutable _FEE_TYPEHASH;
                              bytes32 private immutable _SELL_OFFER_TYPEHASH;
                              bytes32 private immutable _ORACLE_OFFER_TYPEHASH;
                              bytes32 private immutable _EIP_712_DOMAIN_TYPEHASH;
                              string private constant _NAME = "Blend";
                              string private constant _VERSION = "1.0";
                              mapping(address => uint256) public nonces;
                              mapping(address => uint256) public oracles;
                              uint256 public blockRange;
                              uint256[50] private _gap;
                              constructor() {
                                  (
                                      _LOAN_OFFER_TYPEHASH,
                                      _SELL_OFFER_TYPEHASH,
                                      _FEE_TYPEHASH,
                                      _ORACLE_OFFER_TYPEHASH,
                                      _EIP_712_DOMAIN_TYPEHASH
                                  ) = _createTypehashes();
                              }
                              function information() external view returns (string memory version, bytes32 domainSeparator) {
                                  version = _VERSION;
                                  domainSeparator = _hashDomain(
                                      _EIP_712_DOMAIN_TYPEHASH,
                                      keccak256(bytes(_NAME)),
                                      keccak256(bytes(_VERSION))
                                  );
                              }
                              function getSellOfferHash(SellOffer calldata offer) external view returns (bytes32) {
                                  return _hashSellOffer(offer);
                              }
                              function getOfferHash(LoanOffer calldata offer) external view returns (bytes32) {
                                  return _hashOffer(offer);
                              }
                              function getOracleOfferHash(bytes32 hash, uint256 blockNumber) external view returns (bytes32) {
                                  return _hashOracleOffer(hash, blockNumber);
                              }
                              /**
                               * @notice Generate all EIP712 Typehashes
                               */
                              function _createTypehashes()
                                  internal
                                  view
                                  returns (
                                      bytes32 loanOfferTypehash,
                                      bytes32 sellOfferTypehash,
                                      bytes32 feeTypehash,
                                      bytes32 oracleOfferTypehash,
                                      bytes32 eip712DomainTypehash
                                  )
                              {
                                  eip712DomainTypehash = keccak256(
                                      bytes.concat(
                                          "EIP712Domain(",
                                          "string name,",
                                          "string version,",
                                          "uint256 chainId,",
                                          "address verifyingContract",
                                          ")"
                                      )
                                  );
                                  oracleOfferTypehash = keccak256(
                                      bytes.concat("OracleOffer(", "bytes32 hash,", "uint256 blockNumber", ")")
                                  );
                                  loanOfferTypehash = keccak256(
                                      bytes.concat(
                                          "LoanOffer(",
                                          "address lender,",
                                          "address collection,",
                                          "uint256 totalAmount,",
                                          "uint256 minAmount,",
                                          "uint256 maxAmount,",
                                          "uint256 auctionDuration,",
                                          "uint256 salt,",
                                          "uint256 expirationTime,",
                                          "uint256 rate,",
                                          "address oracle,",
                                          "uint256 nonce",
                                          ")"
                                      )
                                  );
                                  bytes memory feeTypestring = bytes.concat("Fee(", "uint16 rate,", "address recipient", ")");
                                  feeTypehash = keccak256(feeTypestring);
                                  sellOfferTypehash = keccak256(
                                      bytes.concat(
                                          "SellOffer(",
                                          "address borrower,",
                                          "uint256 lienId,",
                                          "uint256 price,",
                                          "uint256 expirationTime,",
                                          "uint256 salt,",
                                          "address oracle,",
                                          "Fee[] fees,",
                                          "uint256 nonce",
                                          ")",
                                          feeTypestring
                                      )
                                  );
                              }
                              function _hashDomain(
                                  bytes32 eip712DomainTypehash,
                                  bytes32 nameHash,
                                  bytes32 versionHash
                              ) internal view returns (bytes32) {
                                  return
                                      keccak256(
                                          abi.encode(
                                              eip712DomainTypehash,
                                              nameHash,
                                              versionHash,
                                              block.chainid,
                                              address(this)
                                          )
                                      );
                              }
                              function _hashFee(Fee calldata fee) internal view returns (bytes32) {
                                  return keccak256(abi.encode(_FEE_TYPEHASH, fee.rate, fee.recipient));
                              }
                              function _packFees(Fee[] calldata fees) internal view returns (bytes32) {
                                  bytes32[] memory feeHashes = new bytes32[](fees.length);
                                  uint256 feesLength = fees.length;
                                  for (uint256 i; i < feesLength; ) {
                                      feeHashes[i] = _hashFee(fees[i]);
                                      unchecked {
                                          ++i;
                                      }
                                  }
                                  return keccak256(abi.encodePacked(feeHashes));
                              }
                              function _hashSellOffer(SellOffer calldata offer) internal view returns (bytes32) {
                                  return
                                      keccak256(
                                          abi.encode(
                                              _SELL_OFFER_TYPEHASH,
                                              offer.borrower,
                                              offer.lienId,
                                              offer.price,
                                              offer.expirationTime,
                                              offer.salt,
                                              offer.oracle,
                                              _packFees(offer.fees),
                                              nonces[offer.borrower]
                                          )
                                      );
                              }
                              function _hashOffer(LoanOffer calldata offer) internal view returns (bytes32) {
                                  return
                                      keccak256(
                                          abi.encode(
                                              _LOAN_OFFER_TYPEHASH,
                                              offer.lender,
                                              offer.collection,
                                              offer.totalAmount,
                                              offer.minAmount,
                                              offer.maxAmount,
                                              offer.auctionDuration,
                                              offer.salt,
                                              offer.expirationTime,
                                              offer.rate,
                                              offer.oracle,
                                              nonces[offer.lender]
                                          )
                                      );
                              }
                              function _hashOracleOffer(bytes32 hash, uint256 blockNumber) internal view returns (bytes32) {
                                  return keccak256(abi.encode(_ORACLE_OFFER_TYPEHASH, hash, blockNumber));
                              }
                              function _hashToSign(bytes32 hash) internal view returns (bytes32) {
                                  return keccak256(
                                      bytes.concat(
                                          bytes2(0x1901),
                                          _hashDomain(
                                              _EIP_712_DOMAIN_TYPEHASH,
                                              keccak256(bytes(_NAME)),
                                              keccak256(bytes(_VERSION))
                                          ),
                                          hash
                                      )
                                  );
                              }
                              function _hashToSignOracle(bytes32 hash, uint256 blockNumber) internal view returns (bytes32) {
                                  return
                                      keccak256(
                                          bytes.concat(
                                              bytes2(0x1901),
                                              _hashDomain(
                                                  _EIP_712_DOMAIN_TYPEHASH,
                                                  keccak256(bytes(_NAME)),
                                                  keccak256(bytes(_VERSION))
                                              ),
                                              _hashOracleOffer(hash, blockNumber)
                                          )
                                      );
                              }
                              /**
                               * @notice Verify authorization of offer
                               * @param offerHash Hash of offer struct
                               * @param lender Lender address
                               * @param oracle Oracle address
                               * @param signature Packed offer signature (with oracle signature if necessary)
                               */
                              function _verifyOfferAuthorization(
                                  bytes32 offerHash,
                                  address lender,
                                  address oracle,
                                  bytes calldata signature
                              ) internal view {
                                  bytes32 hashToSign = _hashToSign(offerHash);
                                  bytes32 r;
                                  bytes32 s;
                                  uint8 v;
                                  assembly {
                                      r := calldataload(signature.offset)
                                      s := calldataload(add(signature.offset, 0x20))
                                      v := shr(248, calldataload(add(signature.offset, 0x40)))
                                  }
                                  _verify(lender, hashToSign, v, r, s);
                                  /* Verify oracle signature if required. */
                                  if (oracle != address(0)) {
                                      uint256 blockNumber;
                                      assembly {
                                          r := calldataload(add(signature.offset, 0x41))
                                          s := calldataload(add(signature.offset, 0x61))
                                          v := shr(248, calldataload(add(signature.offset, 0x81)))
                                          blockNumber := calldataload(add(signature.offset, 0x82))
                                      }
                                      if (oracles[oracle] == 0) {
                                          revert UnauthorizedOracle();
                                      }
                                      if (blockNumber + blockRange < block.number) {
                                          revert SignatureExpired();
                                      }
                                      hashToSign = _hashToSignOracle(offerHash, blockNumber);
                                      _verify(oracle, hashToSign, v, r, s);
                                  }
                              }
                              /**
                               * @notice Verify signature of digest
                               * @param signer Address of expected signer
                               * @param digest Signature digest
                               * @param v v parameter
                               * @param r r parameter
                               * @param s s parameter
                               */
                              function _verify(address signer, bytes32 digest, uint8 v, bytes32 r, bytes32 s) internal pure {
                                  if (v != 27 && v != 28) {
                                      revert InvalidVParameter();
                                  }
                                  address recoveredSigner = ecrecover(digest, v, r, s);
                                  if (recoveredSigner == address(0) || signer != recoveredSigner) {
                                      revert InvalidSignature();
                                  }
                              }
                          }
                          // SPDX-License-Identifier: MIT
                          pragma solidity ^0.8.0;
                          import "./ISignatures.sol";
                          interface IOfferController is ISignatures {
                              event OfferCancelled(address indexed user, uint256 salt);
                              event NonceIncremented(address indexed user, uint256 newNonce);
                              function cancelOffer(uint256 salt) external;
                              function cancelOffers(uint256[] calldata salts) external;
                              function incrementNonce() external;
                              /* Admin */
                              function setOracle(address oracle, bool approved) external;
                              function setBlockRange(uint256 blockRange) external;
                          }
                          // 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 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
                          pragma solidity ^0.8.0;
                          import "../lib/Structs.sol";
                          interface ISignatures {
                              function information()
                                  external
                                  view
                                  returns (
                                      string memory version,
                                      bytes32 domainSeparator
                                  );
                              function getOracleOfferHash(bytes32 hash, uint256 blockNumber) external view returns (bytes32);
                              function getSellOfferHash(SellOffer calldata offer) external view returns (bytes32);
                              function getOfferHash(LoanOffer calldata offer) external view returns (bytes32);
                              function cancelledOrFulfilled(address user, uint256 salt) external view returns (uint256);
                              function nonces(address user) external view returns (uint256);
                          }
                          

                          File 6 of 10: Helpers
                          // SPDX-License-Identifier: BSL 1.1 - Blend (c) Non Fungible Trading Ltd.
                          pragma solidity 0.8.17;
                          import "lib/solmate/src/utils/SignedWadMath.sol";
                          import { InvalidRepayment } from "./lib/Errors.sol";
                          import "./lib/Structs.sol";
                          import "../pool/interfaces/IBlurPool.sol";
                          import { IBlurExchangeV2 as IExchangeV2 } from "../exchangeV2/interfaces/IBlurExchangeV2.sol";
                          import { Order as OrderV1, SignatureVersion, Side } from "../exchangeV1/lib/OrderStructs.sol";
                          import {
                              TakeAskSingle,
                              TakeBidSingle,
                              FeeRate,
                              Taker,
                              Exchange,
                              Order as OrderV2,
                              AssetType
                          } from "../exchangeV2/lib/Structs.sol";
                          interface IExchange {
                              function execute(Input calldata sell, Input calldata buy) external payable;
                          }
                          library Helpers {
                              int256 private constant _YEAR_WAD = 365 days * 1e18;
                              uint256 private constant _LIQUIDATION_THRESHOLD = 100_000;
                              uint256 private constant _BASIS_POINTS = 10_000;
                              error InvalidExecution();
                              /**
                               * @dev Computes the current debt of a borrow given the last time it was touched and the last computed debt.
                               * @param amount Principal in ETH
                               * @param startTime Start time of the loan
                               * @param rate Interest rate (in bips)
                               * @dev Formula: https://www.desmos.com/calculator/l6omp0rwnh
                               */
                              function computeCurrentDebt(
                                  uint256 amount,
                                  uint256 rate,
                                  uint256 startTime
                              ) public view returns (uint256) {
                                  uint256 loanTime = block.timestamp - startTime;
                                  int256 yearsWad = wadDiv(int256(loanTime) * 1e18, _YEAR_WAD);
                                  return uint256(wadMul(int256(amount), wadExp(wadMul(yearsWad, bipsToSignedWads(rate)))));
                              }
                              /**
                               * @dev Calculates the current maximum interest rate a specific refinancing
                               * auction could settle at currently given the auction's start block and duration.
                               * @param startBlock The block the auction started at
                               * @param oldRate Previous interest rate (in bips)
                               * @dev Formula: https://www.desmos.com/calculator/urasr71dhb
                               */
                              function calcRefinancingAuctionRate(
                                  uint256 startBlock,
                                  uint256 auctionDuration,
                                  uint256 oldRate
                              ) public view returns (uint256) {
                                  uint256 currentAuctionBlock = block.number - startBlock;
                                  int256 oldRateWads = bipsToSignedWads(oldRate);
                                  uint256 auctionT1 = auctionDuration / 5;
                                  uint256 auctionT2 = (4 * auctionDuration) / 5;
                                  int256 maxRateWads;
                                  {
                                      int256 aInverse = -bipsToSignedWads(15000);
                                      int256 b = 2;
                                      int256 maxMinRateWads = bipsToSignedWads(500);
                                      if (oldRateWads < -((b * aInverse) / 2)) {
                                          maxRateWads = maxMinRateWads + (oldRateWads ** 2) / aInverse + b * oldRateWads;
                                      } else {
                                          maxRateWads = maxMinRateWads - ((b ** 2) * aInverse) / 4;
                                      }
                                  }
                                  int256 startSlope = maxRateWads / int256(auctionT1); // wad-bips per block
                                  int256 middleSlope = bipsToSignedWads(9000) / int256((3 * auctionDuration) / 5) + 1; // wad-bips per block (add one to account for rounding)
                                  int256 middleB = maxRateWads - int256(auctionT1) * middleSlope;
                                  if (currentAuctionBlock < auctionT1) {
                                      return signedWadsToBips(startSlope * int256(currentAuctionBlock));
                                  } else if (currentAuctionBlock < auctionT2) {
                                      return signedWadsToBips(middleSlope * int256(currentAuctionBlock) + middleB);
                                  } else if (currentAuctionBlock < auctionDuration) {
                                      int256 endSlope;
                                      int256 endB;
                                      {
                                          endSlope =
                                              (bipsToSignedWads(_LIQUIDATION_THRESHOLD) -
                                                  ((int256(auctionT2) * middleSlope) + middleB)) /
                                              int256(auctionDuration - auctionT2); // wad-bips per block
                                          endB =
                                              bipsToSignedWads(_LIQUIDATION_THRESHOLD) -
                                              int256(auctionDuration) *
                                              endSlope;
                                      }
                                      return signedWadsToBips(endSlope * int256(currentAuctionBlock) + endB);
                                  } else {
                                      return _LIQUIDATION_THRESHOLD;
                                  }
                              }
                              /**
                               * @dev Converts an integer bips value to a signed wad value.
                               */
                              function bipsToSignedWads(uint256 bips) public pure returns (int256) {
                                  return int256((bips * 1e18) / _BASIS_POINTS);
                              }
                              /**
                               * @dev Converts a signed wad value to an integer bips value.
                               */
                              function signedWadsToBips(int256 wads) public pure returns (uint256) {
                                  return uint256((wads * int256(_BASIS_POINTS)) / 1e18);
                              }
                              function executeTakeBid(
                                  Lien calldata lien,
                                  uint256 lienId,
                                  ExecutionV1 calldata execution,
                                  uint256 debt,
                                  IBlurPool pool,
                                  IExchange exchange,
                                  address delegate,
                                  address matchingPolicy
                              ) external {
                                  /* Create sell side order from Blend. */
                                  OrderV1 memory sellOrder = OrderV1({
                                      trader: address(this),
                                      side: Side.Sell,
                                      matchingPolicy: matchingPolicy,
                                      collection: address(lien.collection),
                                      tokenId: lien.tokenId,
                                      amount: 1,
                                      paymentToken: address(pool),
                                      price: execution.makerOrder.order.price,
                                      listingTime: execution.makerOrder.order.listingTime + 1, // listingTime determines maker/taker
                                      expirationTime: type(uint256).max,
                                      fees: new Fee[](0),
                                      salt: lienId, // prevent reused order hash
                                      extraParams: "\\x01" // require oracle signature
                                  });
                                  Input memory sell = Input({
                                      order: sellOrder,
                                      v: 0,
                                      r: bytes32(0),
                                      s: bytes32(0),
                                      extraSignature: execution.extraSignature,
                                      signatureVersion: SignatureVersion.Single,
                                      blockNumber: execution.blockNumber
                                  });
                                  /* Execute marketplace order. */
                                  uint256 balanceBefore = pool.balanceOf(address(this));
                                  lien.collection.approve(delegate, lien.tokenId);
                                  exchange.execute(sell, execution.makerOrder);
                                  /* Determine the funds received from the sale (after fees). */
                                  uint256 amountReceivedFromSale = pool.balanceOf(address(this)) - balanceBefore;
                                  if (amountReceivedFromSale < debt) {
                                      revert InvalidRepayment();
                                  }
                                  /* Repay lender. */
                                  pool.transferFrom(address(this), lien.lender, debt);
                                  /* Send surplus to borrower. */
                                  unchecked {
                                      pool.transferFrom(address(this), lien.borrower, amountReceivedFromSale - debt);
                                  }
                              }
                              function executeTakeAskV2(
                                  LoanOffer calldata offer, 
                                  AskExecutionV2 calldata execution,
                                  uint256 loanAmount,
                                  uint256 collateralTokenId,
                                  uint256 price,
                                  IBlurPool pool,
                                  IExchangeV2 exchangeV2
                              ) external {
                                  OrderV2 calldata order = execution.order;
                                  if (address(offer.collection) != order.collection || order.assetType != AssetType.ERC721) {
                                      revert InvalidExecution();
                                  }
                                  /* Transfer funds. */
                                  /* Need to retrieve the ETH to fund the marketplace execution. */
                                  if (loanAmount < price) {
                                      /* Take funds from lender. */
                                      pool.withdrawFrom(offer.lender, address(this), loanAmount);
                                      /* Supplement difference from borrower. */
                                      unchecked {
                                          pool.withdrawFrom(msg.sender, address(this), price - loanAmount);
                                      }
                                  } else {
                                      /* Take funds from lender. */
                                      pool.withdrawFrom(offer.lender, address(this), price);
                                      /* Send surplus to borrower. */
                                      unchecked {
                                          pool.transferFrom(offer.lender, msg.sender, loanAmount - price);
                                      }
                                  }
                                  TakeAskSingle memory execute = TakeAskSingle({
                                      order: execution.order,
                                      exchange: Exchange({
                                          index: 0,
                                          proof: execution.proof,
                                          listing: Listing({
                                              index: execution.listing.index,
                                              tokenId: collateralTokenId,
                                              amount: 1,
                                              price: price
                                          }),
                                          taker: Taker({ tokenId: collateralTokenId, amount: 1 })
                                      }),
                                      takerFee: FeeRate(address(0), 0),
                                      signature: execution.signature,
                                      tokenRecipient: address(this)
                                  });
                                  exchangeV2.takeAskSingle{ value: price }(execute, execution.oracleSignature);
                              }
                              function executeTakeAsk(
                                  LoanOffer calldata offer,
                                  ExecutionV1 calldata execution,
                                  uint256 loanAmount,
                                  uint256 collateralTokenId,
                                  uint256 price,
                                  IBlurPool pool,
                                  IExchange exchange,
                                  address matchingPolicy
                              ) external {
                                  /* Transfer funds. */
                                  /* Need to retrieve the ETH to fund the marketplace execution. */
                                  if (loanAmount < price) {
                                      /* Take funds from lender. */
                                      pool.withdrawFrom(offer.lender, address(this), loanAmount);
                                      /* Supplement difference from borrower. */
                                      unchecked {
                                          pool.withdrawFrom(msg.sender, address(this), price - loanAmount);
                                      }
                                  } else {
                                      /* Take funds from lender. */
                                      pool.withdrawFrom(offer.lender, address(this), price);
                                      /* Send surplus to borrower. */
                                      unchecked {
                                          pool.transferFrom(offer.lender, msg.sender, loanAmount - price);
                                      }
                                  }
                                  OrderV1 memory buyOrder = OrderV1({
                                      trader: address(this),
                                      side: Side.Buy,
                                      matchingPolicy: matchingPolicy,
                                      collection: address(offer.collection),
                                      tokenId: collateralTokenId,
                                      amount: 1,
                                      paymentToken: address(0),
                                      price: price,
                                      listingTime: execution.makerOrder.order.listingTime + 1, // listingTime determines maker/taker
                                      expirationTime: type(uint256).max,
                                      fees: new Fee[](0),
                                      salt: uint160(execution.makerOrder.order.trader), // prevent reused order hash
                                      extraParams: "\\x01" // require oracle signature
                                  });
                                  Input memory buy = Input({
                                      order: buyOrder,
                                      v: 0,
                                      r: bytes32(0),
                                      s: bytes32(0),
                                      extraSignature: execution.extraSignature,
                                      signatureVersion: SignatureVersion.Single,
                                      blockNumber: execution.blockNumber
                                  });
                                  /* Execute order using ETH currently in contract. */
                                  exchange.execute{ value: price }(execution.makerOrder, buy);
                              }
                              function executeTakeBidV2(
                                  Lien calldata lien,
                                  BidExecutionV2 calldata execution,
                                  uint256 debt,
                                  IBlurPool pool,
                                  IExchangeV2 exchangeV2,
                                  address delegateV2
                              ) external {
                                  OrderV2 calldata order = execution.order;
                                  if (address(lien.collection) != order.collection || order.assetType != AssetType.ERC721) {
                                      revert InvalidExecution();
                                  }
                                  uint256 balanceBefore = pool.balanceOf(address(this));
                                  TakeBidSingle memory execute = TakeBidSingle({
                                      order: execution.order,
                                      exchange: Exchange({
                                          index: 0,
                                          proof: execution.proof,
                                          listing: execution.listing,
                                          taker: Taker({ tokenId: lien.tokenId, amount: 1 })
                                      }),
                                      takerFee: FeeRate(address(0), 0),
                                      signature: execution.signature
                                  });
                                  /* Execute marketplace order. */
                                  lien.collection.approve(delegateV2, lien.tokenId);
                                  exchangeV2.takeBidSingle(execute, execution.oracleSignature);
                                  /* Determine the funds received from the sale (after fees). */
                                  uint256 amountReceivedFromSale = pool.balanceOf(address(this)) - balanceBefore;
                                  if (amountReceivedFromSale < debt) {
                                      revert InvalidRepayment();
                                  }
                                  /* Repay lender. */
                                  pool.transferFrom(address(this), lien.lender, debt);
                                  /* Send surplus to borrower. */
                                  unchecked {
                                      pool.transferFrom(address(this), lien.borrower, amountReceivedFromSale - debt);
                                  }
                              }
                          }
                          // SPDX-License-Identifier: MIT
                          pragma solidity >=0.8.0;
                          /// @notice Signed 18 decimal fixed point (wad) arithmetic library.
                          /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SignedWadMath.sol)
                          /// @author Modified from Remco Bloemen (https://xn--2-umb.com/22/exp-ln/index.html)
                          /// @dev Will not revert on overflow, only use where overflow is not possible.
                          function toWadUnsafe(uint256 x) pure returns (int256 r) {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  // Multiply x by 1e18.
                                  r := mul(x, 1000000000000000000)
                              }
                          }
                          /// @dev Takes an integer amount of seconds and converts it to a wad amount of days.
                          /// @dev Will not revert on overflow, only use where overflow is not possible.
                          /// @dev Not meant for negative second amounts, it assumes x is positive.
                          function toDaysWadUnsafe(uint256 x) pure returns (int256 r) {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  // Multiply x by 1e18 and then divide it by 86400.
                                  r := div(mul(x, 1000000000000000000), 86400)
                              }
                          }
                          /// @dev Takes a wad amount of days and converts it to an integer amount of seconds.
                          /// @dev Will not revert on overflow, only use where overflow is not possible.
                          /// @dev Not meant for negative day amounts, it assumes x is positive.
                          function fromDaysWadUnsafe(int256 x) pure returns (uint256 r) {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  // Multiply x by 86400 and then divide it by 1e18.
                                  r := div(mul(x, 86400), 1000000000000000000)
                              }
                          }
                          /// @dev Will not revert on overflow, only use where overflow is not possible.
                          function unsafeWadMul(int256 x, int256 y) pure returns (int256 r) {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  // Multiply x by y and divide by 1e18.
                                  r := sdiv(mul(x, y), 1000000000000000000)
                              }
                          }
                          /// @dev Will return 0 instead of reverting if y is zero and will
                          /// not revert on overflow, only use where overflow is not possible.
                          function unsafeWadDiv(int256 x, int256 y) pure returns (int256 r) {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  // Multiply x by 1e18 and divide it by y.
                                  r := sdiv(mul(x, 1000000000000000000), y)
                              }
                          }
                          function wadMul(int256 x, int256 y) pure returns (int256 r) {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  // Store x * y in r for now.
                                  r := mul(x, y)
                                  // Equivalent to require(x == 0 || (x * y) / x == y)
                                  if iszero(or(iszero(x), eq(sdiv(r, x), y))) {
                                      revert(0, 0)
                                  }
                                  // Scale the result down by 1e18.
                                  r := sdiv(r, 1000000000000000000)
                              }
                          }
                          function wadDiv(int256 x, int256 y) pure returns (int256 r) {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  // Store x * 1e18 in r for now.
                                  r := mul(x, 1000000000000000000)
                                  // Equivalent to require(y != 0 && ((x * 1e18) / 1e18 == x))
                                  if iszero(and(iszero(iszero(y)), eq(sdiv(r, 1000000000000000000), x))) {
                                      revert(0, 0)
                                  }
                                  // Divide r by y.
                                  r := sdiv(r, y)
                              }
                          }
                          /// @dev Will not work with negative bases, only use when x is positive.
                          function wadPow(int256 x, int256 y) pure returns (int256) {
                              // Equivalent to x to the power of y because x ** y = (e ** ln(x)) ** y = e ** (ln(x) * y)
                              return wadExp((wadLn(x) * y) / 1e18); // Using ln(x) means x must be greater than 0.
                          }
                          function wadExp(int256 x) pure returns (int256 r) {
                              unchecked {
                                  // When the result is < 0.5 we return zero. This happens when
                                  // x <= floor(log(0.5e18) * 1e18) ~ -42e18
                                  if (x <= -42139678854452767551) return 0;
                                  // When the result is > (2**255 - 1) / 1e18 we can not represent it as an
                                  // int. This happens when x >= floor(log((2**255 - 1) / 1e18) * 1e18) ~ 135.
                                  if (x >= 135305999368893231589) revert("EXP_OVERFLOW");
                                  // x is now in the range (-42, 136) * 1e18. Convert to (-42, 136) * 2**96
                                  // for more intermediate precision and a binary basis. This base conversion
                                  // is a multiplication by 1e18 / 2**96 = 5**18 / 2**78.
                                  x = (x << 78) / 5**18;
                                  // Reduce range of x to (-½ ln 2, ½ ln 2) * 2**96 by factoring out powers
                                  // of two such that exp(x) = exp(x') * 2**k, where k is an integer.
                                  // Solving this gives k = round(x / log(2)) and x' = x - k * log(2).
                                  int256 k = ((x << 96) / 54916777467707473351141471128 + 2**95) >> 96;
                                  x = x - k * 54916777467707473351141471128;
                                  // k is in the range [-61, 195].
                                  // Evaluate using a (6, 7)-term rational approximation.
                                  // p is made monic, we'll multiply by a scale factor later.
                                  int256 y = x + 1346386616545796478920950773328;
                                  y = ((y * x) >> 96) + 57155421227552351082224309758442;
                                  int256 p = y + x - 94201549194550492254356042504812;
                                  p = ((p * y) >> 96) + 28719021644029726153956944680412240;
                                  p = p * x + (4385272521454847904659076985693276 << 96);
                                  // We leave p in 2**192 basis so we don't need to scale it back up for the division.
                                  int256 q = x - 2855989394907223263936484059900;
                                  q = ((q * x) >> 96) + 50020603652535783019961831881945;
                                  q = ((q * x) >> 96) - 533845033583426703283633433725380;
                                  q = ((q * x) >> 96) + 3604857256930695427073651918091429;
                                  q = ((q * x) >> 96) - 14423608567350463180887372962807573;
                                  q = ((q * x) >> 96) + 26449188498355588339934803723976023;
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      // Div in assembly because solidity adds a zero check despite the unchecked.
                                      // The q polynomial won't have zeros in the domain as all its roots are complex.
                                      // No scaling is necessary because p is already 2**96 too large.
                                      r := sdiv(p, q)
                                  }
                                  // r should be in the range (0.09, 0.25) * 2**96.
                                  // We now need to multiply r by:
                                  // * the scale factor s = ~6.031367120.
                                  // * the 2**k factor from the range reduction.
                                  // * the 1e18 / 2**96 factor for base conversion.
                                  // We do this all at once, with an intermediate result in 2**213
                                  // basis, so the final right shift is always by a positive amount.
                                  r = int256((uint256(r) * 3822833074963236453042738258902158003155416615667) >> uint256(195 - k));
                              }
                          }
                          function wadLn(int256 x) pure returns (int256 r) {
                              unchecked {
                                  require(x > 0, "UNDEFINED");
                                  // We want to convert x from 10**18 fixed point to 2**96 fixed point.
                                  // We do this by multiplying by 2**96 / 10**18. But since
                                  // ln(x * C) = ln(x) + ln(C), we can simply do nothing here
                                  // and add ln(2**96 / 10**18) at the end.
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
                                      r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
                                      r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
                                      r := or(r, shl(4, lt(0xffff, shr(r, x))))
                                      r := or(r, shl(3, lt(0xff, shr(r, x))))
                                      r := or(r, shl(2, lt(0xf, shr(r, x))))
                                      r := or(r, shl(1, lt(0x3, shr(r, x))))
                                      r := or(r, lt(0x1, shr(r, x)))
                                  }
                                  // Reduce range of x to (1, 2) * 2**96
                                  // ln(2^k * x) = k * ln(2) + ln(x)
                                  int256 k = r - 96;
                                  x <<= uint256(159 - k);
                                  x = int256(uint256(x) >> 159);
                                  // Evaluate using a (8, 8)-term rational approximation.
                                  // p is made monic, we will multiply by a scale factor later.
                                  int256 p = x + 3273285459638523848632254066296;
                                  p = ((p * x) >> 96) + 24828157081833163892658089445524;
                                  p = ((p * x) >> 96) + 43456485725739037958740375743393;
                                  p = ((p * x) >> 96) - 11111509109440967052023855526967;
                                  p = ((p * x) >> 96) - 45023709667254063763336534515857;
                                  p = ((p * x) >> 96) - 14706773417378608786704636184526;
                                  p = p * x - (795164235651350426258249787498 << 96);
                                  // We leave p in 2**192 basis so we don't need to scale it back up for the division.
                                  // q is monic by convention.
                                  int256 q = x + 5573035233440673466300451813936;
                                  q = ((q * x) >> 96) + 71694874799317883764090561454958;
                                  q = ((q * x) >> 96) + 283447036172924575727196451306956;
                                  q = ((q * x) >> 96) + 401686690394027663651624208769553;
                                  q = ((q * x) >> 96) + 204048457590392012362485061816622;
                                  q = ((q * x) >> 96) + 31853899698501571402653359427138;
                                  q = ((q * x) >> 96) + 909429971244387300277376558375;
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      // Div in assembly because solidity adds a zero check despite the unchecked.
                                      // The q polynomial is known not to have zeros in the domain.
                                      // No scaling required because p is already 2**96 too large.
                                      r := sdiv(p, q)
                                  }
                                  // r is in the range (0, 0.125) * 2**96
                                  // Finalization, we need to:
                                  // * multiply by the scale factor s = 5.549…
                                  // * add ln(2**96 / 10**18)
                                  // * add k * ln(2)
                                  // * multiply by 10**18 / 2**96 = 5**18 >> 78
                                  // mul s * 5e18 * 2**96, base is now 5**18 * 2**192
                                  r *= 1677202110996718588342820967067443963516166;
                                  // add ln(2) * k * 5e18 * 2**192
                                  r += 16597577552685614221487285958193947469193820559219878177908093499208371 * k;
                                  // add ln(2**96 / 10**18) * 5e18 * 2**192
                                  r += 600920179829731861736702779321621459595472258049074101567377883020018308;
                                  // base conversion: mul 2**18 / 2**192
                                  r >>= 174;
                              }
                          }
                          /// @dev Will return 0 instead of reverting if y is zero.
                          function unsafeDiv(int256 x, int256 y) pure returns (int256 r) {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  // Divide x by y.
                                  r := sdiv(x, y)
                              }
                          }
                          // SPDX-License-Identifier: BSL 1.1 - Blend (c) Non Fungible Trading Ltd.
                          pragma solidity 0.8.17;
                          // Blend
                          error Unauthorized();
                          error InvalidLoan();
                          error InvalidLien();
                          error InsufficientOffer();
                          error InvalidRepayment();
                          error LienIsDefaulted();
                          error LienNotDefaulted();
                          error AuctionIsActive();
                          error AuctionIsNotActive();
                          error InvalidRefinance();
                          error RateTooHigh();
                          error FeesTooHigh();
                          error CollectionsDoNotMatch();
                          error InvalidAuctionDuration();
                          // OfferController
                          error OfferExpired();
                          error OfferUnavailable();
                          // Signatures
                          error UnauthorizedOracle();
                          error SignatureExpired();
                          error InvalidSignature();
                          error InvalidVParameter();
                          // SPDX-License-Identifier: MIT
                          pragma solidity 0.8.17;
                          import "lib/solmate/src/tokens/ERC721.sol";
                          import { Input, Fee } from "../../exchangeV1/lib/OrderStructs.sol";
                          import { Order as OrderV2, Listing } from "../../exchangeV2/lib/Structs.sol";
                          struct LienPointer {
                              Lien lien;
                              uint256 lienId;
                          }
                          struct SellOffer {
                              address borrower;
                              uint256 lienId;
                              uint256 price;
                              uint256 expirationTime;
                              uint256 salt;
                              address oracle;
                              Fee[] fees;
                          }
                          struct Lien {
                              address lender;
                              address borrower;
                              ERC721 collection;
                              uint256 tokenId;
                              uint256 amount;
                              uint256 startTime;
                              uint256 rate;
                              uint256 auctionStartBlock;
                              uint256 auctionDuration;
                          }
                          struct LoanOffer {
                              address lender;
                              ERC721 collection;
                              uint256 totalAmount;
                              uint256 minAmount;
                              uint256 maxAmount;
                              uint256 auctionDuration;
                              uint256 salt;
                              uint256 expirationTime;
                              uint256 rate;
                              address oracle;
                          }
                          struct LoanInput {
                              LoanOffer offer;
                              bytes signature;
                          }
                          struct SellInput {
                              SellOffer offer;
                              bytes signature;
                          }
                          struct ExecutionV1 {
                              Input makerOrder;
                              bytes extraSignature;
                              uint256 blockNumber;
                          }
                          struct BidExecutionV2 {
                              OrderV2 order;
                              Listing listing;
                              bytes32[] proof;
                              bytes signature;
                              bytes oracleSignature;
                          }
                          struct AskExecutionV2 {
                              OrderV2 order;
                              Listing listing;
                              bytes32[] proof;
                              bytes signature;
                              bytes oracleSignature;
                          }
                          // SPDX-License-Identifier: MIT
                          pragma solidity ^0.8.0;
                          interface IBlurPool {
                              event Transfer(address indexed from, address indexed to, uint256 amount);
                              function initialize() external;
                              function decimals() external pure returns (uint8);
                              function totalSupply() external view returns (uint256);
                              function balanceOf(address user) external view returns (uint256);
                              function deposit() external payable;
                              function deposit(address user) external payable;
                              function withdraw(uint256 amount) external;
                              function withdrawFrom(address from, address to, uint256 amount) external;
                              function transferFrom(address from, address to, uint256 amount) external returns (bool);
                          }
                          // SPDX-License-Identifier: MIT
                          pragma solidity 0.8.17;
                          import {
                              TakeAsk,
                              TakeBid,
                              TakeAskSingle,
                              TakeBidSingle,
                              Order,
                              Exchange,
                              Fees,
                              FeeRate,
                              AssetType,
                              OrderType,
                              Transfer,
                              FungibleTransfers,
                              StateUpdate,
                              Cancel,
                              Listing
                          } from "../lib/Structs.sol";
                          interface IBlurExchangeV2 {
                              error InsufficientFunds();
                              error TokenTransferFailed();
                              error InvalidOrder();
                              error ProtocolFeeTooHigh();
                              event NewProtocolFee(address indexed recipient, uint16 indexed rate);
                              event NewGovernor(address indexed governor);
                              event NewBlockRange(uint256 blockRange);
                              event CancelTrade(address indexed user, bytes32 hash, uint256 index, uint256 amount);
                              event NonceIncremented(address indexed user, uint256 newNonce);
                              event SetOracle(address indexed user, bool approved);
                              function initialize() external;
                              function setProtocolFee(address recipient, uint16 rate) external;
                              function setGovernor(address _governor) external;
                              function setOracle(address oracle, bool approved) external;
                              function setBlockRange(uint256 _blockRange) external;
                              function cancelTrades(Cancel[] memory cancels) external;
                              function incrementNonce() external;
                              /*//////////////////////////////////////////////////////////////
                                                    EXECUTION WRAPPERS
                              //////////////////////////////////////////////////////////////*/
                              function takeAsk(TakeAsk memory inputs, bytes calldata oracleSignature) external payable;
                              function takeBid(TakeBid memory inputs, bytes calldata oracleSignature) external;
                              function takeAskSingle(TakeAskSingle memory inputs, bytes calldata oracleSignature) external payable;
                              function takeBidSingle(TakeBidSingle memory inputs, bytes calldata oracleSignature) external;
                              /*//////////////////////////////////////////////////////////////
                                                  EXECUTION POOL WRAPPERS
                              //////////////////////////////////////////////////////////////*/
                              function takeAskSinglePool(
                                  TakeAskSingle memory inputs,
                                  bytes calldata oracleSignature,
                                  uint256 amountToWithdraw
                              ) external payable;
                              function takeAskPool(
                                  TakeAsk memory inputs,
                                  bytes calldata oracleSignature,
                                  uint256 amountToWithdraw
                              ) external payable;
                          }
                          // SPDX-License-Identifier: MIT
                          pragma solidity 0.8.17;
                          enum Side { Buy, Sell }
                          enum SignatureVersion { Single, Bulk }
                          enum AssetType { ERC721, ERC1155 }
                          struct Fee {
                              uint16 rate;
                              address payable recipient;
                          }
                          struct Order {
                              address trader;
                              Side side;
                              address matchingPolicy;
                              address collection;
                              uint256 tokenId;
                              uint256 amount;
                              address paymentToken;
                              uint256 price;
                              uint256 listingTime;
                              /* Order expiration timestamp - 0 for oracle cancellations. */
                              uint256 expirationTime;
                              Fee[] fees;
                              uint256 salt;
                              bytes extraParams;
                          }
                          struct Input {
                              Order order;
                              uint8 v;
                              bytes32 r;
                              bytes32 s;
                              bytes extraSignature;
                              SignatureVersion signatureVersion;
                              uint256 blockNumber;
                          }
                          struct Execution {
                            Input sell;
                            Input buy;
                          }
                          // SPDX-License-Identifier: MIT
                          pragma solidity ^0.8.17;
                          struct TakeAsk {
                              Order[] orders;
                              Exchange[] exchanges;
                              FeeRate takerFee;
                              bytes signatures;
                              address tokenRecipient;
                          }
                          struct TakeAskSingle {
                              Order order;
                              Exchange exchange;
                              FeeRate takerFee;
                              bytes signature;
                              address tokenRecipient;
                          }
                          struct TakeBid {
                              Order[] orders;
                              Exchange[] exchanges;
                              FeeRate takerFee;
                              bytes signatures;
                          }
                          struct TakeBidSingle {
                              Order order;
                              Exchange exchange;
                              FeeRate takerFee;
                              bytes signature;
                          }
                          enum AssetType {
                              ERC721,
                              ERC1155
                          }
                          enum OrderType {
                              ASK,
                              BID
                          }
                          struct Exchange { // Size: 0x80
                              uint256 index; // 0x00
                              bytes32[] proof; // 0x20
                              Listing listing; // 0x40
                              Taker taker; // 0x60
                          }
                          struct Listing { // Size: 0x80
                              uint256 index; // 0x00
                              uint256 tokenId; // 0x20
                              uint256 amount; // 0x40
                              uint256 price; // 0x60
                          }
                          struct Taker { // Size: 0x40
                              uint256 tokenId; // 0x00
                              uint256 amount; // 0x20
                          }
                          struct Order { // Size: 0x100
                              address trader; // 0x00
                              address collection; // 0x20
                              bytes32 listingsRoot; // 0x40
                              uint256 numberOfListings; // 0x60
                              uint256 expirationTime; // 0x80
                              AssetType assetType; // 0xa0
                              FeeRate makerFee; // 0xc0
                              uint256 salt; // 0xe0
                          }
                          /*
                          Reference only; struct is composed manually using calldata formatting in execution
                          struct ExecutionBatch { // Size: 0x80
                              address taker; // 0x00
                              OrderType orderType; // 0x20
                              Transfer[] transfers; // 0x40
                              uint256 length; // 0x60
                          }
                          */
                          struct Transfer { // Size: 0xa0
                              address trader; // 0x00
                              uint256 id; // 0x20
                              uint256 amount; // 0x40
                              address collection; // 0x60
                              AssetType assetType; // 0x80
                          }
                          struct FungibleTransfers {
                              uint256 totalProtocolFee;
                              uint256 totalSellerTransfer;
                              uint256 totalTakerFee;
                              uint256 feeRecipientId;
                              uint256 makerId;
                              address[] feeRecipients;
                              address[] makers;
                              uint256[] makerTransfers;
                              uint256[] feeTransfers;
                              AtomicExecution[] executions;
                          }
                          struct AtomicExecution { // Size: 0xe0
                              uint256 makerId; // 0x00
                              uint256 sellerAmount; // 0x20
                              uint256 makerFeeRecipientId; // 0x40
                              uint256 makerFeeAmount; // 0x60
                              uint256 takerFeeAmount; // 0x80
                              uint256 protocolFeeAmount; // 0xa0
                              StateUpdate stateUpdate; // 0xc0
                          }
                          struct StateUpdate { // Size: 0xa0
                              address trader; // 0x00
                              bytes32 hash; // 0x20
                              uint256 index; // 0x40
                              uint256 value; // 0x60
                              uint256 maxAmount; // 0x80
                          }
                          struct Fees { // Size: 0x40
                              FeeRate protocolFee; // 0x00
                              FeeRate takerFee; // 0x20
                          }
                          struct FeeRate { // Size: 0x40
                              address recipient; // 0x00
                              uint16 rate; // 0x20
                          }
                          struct Cancel {
                              bytes32 hash;
                              uint256 index;
                              uint256 amount;
                          }
                          // SPDX-License-Identifier: AGPL-3.0-only
                          pragma solidity >=0.8.0;
                          /// @notice Modern, minimalist, and gas efficient ERC-721 implementation.
                          /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC721.sol)
                          abstract contract ERC721 {
                              /*//////////////////////////////////////////////////////////////
                                                           EVENTS
                              //////////////////////////////////////////////////////////////*/
                              event Transfer(address indexed from, address indexed to, uint256 indexed id);
                              event Approval(address indexed owner, address indexed spender, uint256 indexed id);
                              event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
                              /*//////////////////////////////////////////////////////////////
                                                   METADATA STORAGE/LOGIC
                              //////////////////////////////////////////////////////////////*/
                              string public name;
                              string public symbol;
                              function tokenURI(uint256 id) public view virtual returns (string memory);
                              /*//////////////////////////////////////////////////////////////
                                                ERC721 BALANCE/OWNER STORAGE
                              //////////////////////////////////////////////////////////////*/
                              mapping(uint256 => address) internal _ownerOf;
                              mapping(address => uint256) internal _balanceOf;
                              function ownerOf(uint256 id) public view virtual returns (address owner) {
                                  require((owner = _ownerOf[id]) != address(0), "NOT_MINTED");
                              }
                              function balanceOf(address owner) public view virtual returns (uint256) {
                                  require(owner != address(0), "ZERO_ADDRESS");
                                  return _balanceOf[owner];
                              }
                              /*//////////////////////////////////////////////////////////////
                                                   ERC721 APPROVAL STORAGE
                              //////////////////////////////////////////////////////////////*/
                              mapping(uint256 => address) public getApproved;
                              mapping(address => mapping(address => bool)) public isApprovedForAll;
                              /*//////////////////////////////////////////////////////////////
                                                         CONSTRUCTOR
                              //////////////////////////////////////////////////////////////*/
                              constructor(string memory _name, string memory _symbol) {
                                  name = _name;
                                  symbol = _symbol;
                              }
                              /*//////////////////////////////////////////////////////////////
                                                        ERC721 LOGIC
                              //////////////////////////////////////////////////////////////*/
                              function approve(address spender, uint256 id) public virtual {
                                  address owner = _ownerOf[id];
                                  require(msg.sender == owner || isApprovedForAll[owner][msg.sender], "NOT_AUTHORIZED");
                                  getApproved[id] = spender;
                                  emit Approval(owner, spender, id);
                              }
                              function setApprovalForAll(address operator, bool approved) public virtual {
                                  isApprovedForAll[msg.sender][operator] = approved;
                                  emit ApprovalForAll(msg.sender, operator, approved);
                              }
                              function transferFrom(
                                  address from,
                                  address to,
                                  uint256 id
                              ) public virtual {
                                  require(from == _ownerOf[id], "WRONG_FROM");
                                  require(to != address(0), "INVALID_RECIPIENT");
                                  require(
                                      msg.sender == from || isApprovedForAll[from][msg.sender] || msg.sender == getApproved[id],
                                      "NOT_AUTHORIZED"
                                  );
                                  // Underflow of the sender's balance is impossible because we check for
                                  // ownership above and the recipient's balance can't realistically overflow.
                                  unchecked {
                                      _balanceOf[from]--;
                                      _balanceOf[to]++;
                                  }
                                  _ownerOf[id] = to;
                                  delete getApproved[id];
                                  emit Transfer(from, to, id);
                              }
                              function safeTransferFrom(
                                  address from,
                                  address to,
                                  uint256 id
                              ) public virtual {
                                  transferFrom(from, to, id);
                                  require(
                                      to.code.length == 0 ||
                                          ERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, "") ==
                                          ERC721TokenReceiver.onERC721Received.selector,
                                      "UNSAFE_RECIPIENT"
                                  );
                              }
                              function safeTransferFrom(
                                  address from,
                                  address to,
                                  uint256 id,
                                  bytes calldata data
                              ) public virtual {
                                  transferFrom(from, to, id);
                                  require(
                                      to.code.length == 0 ||
                                          ERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, data) ==
                                          ERC721TokenReceiver.onERC721Received.selector,
                                      "UNSAFE_RECIPIENT"
                                  );
                              }
                              /*//////////////////////////////////////////////////////////////
                                                        ERC165 LOGIC
                              //////////////////////////////////////////////////////////////*/
                              function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
                                  return
                                      interfaceId == 0x01ffc9a7 || // ERC165 Interface ID for ERC165
                                      interfaceId == 0x80ac58cd || // ERC165 Interface ID for ERC721
                                      interfaceId == 0x5b5e139f; // ERC165 Interface ID for ERC721Metadata
                              }
                              /*//////////////////////////////////////////////////////////////
                                                  INTERNAL MINT/BURN LOGIC
                              //////////////////////////////////////////////////////////////*/
                              function _mint(address to, uint256 id) internal virtual {
                                  require(to != address(0), "INVALID_RECIPIENT");
                                  require(_ownerOf[id] == address(0), "ALREADY_MINTED");
                                  // Counter overflow is incredibly unrealistic.
                                  unchecked {
                                      _balanceOf[to]++;
                                  }
                                  _ownerOf[id] = to;
                                  emit Transfer(address(0), to, id);
                              }
                              function _burn(uint256 id) internal virtual {
                                  address owner = _ownerOf[id];
                                  require(owner != address(0), "NOT_MINTED");
                                  // Ownership check above ensures no underflow.
                                  unchecked {
                                      _balanceOf[owner]--;
                                  }
                                  delete _ownerOf[id];
                                  delete getApproved[id];
                                  emit Transfer(owner, address(0), id);
                              }
                              /*//////////////////////////////////////////////////////////////
                                                  INTERNAL SAFE MINT LOGIC
                              //////////////////////////////////////////////////////////////*/
                              function _safeMint(address to, uint256 id) internal virtual {
                                  _mint(to, id);
                                  require(
                                      to.code.length == 0 ||
                                          ERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, "") ==
                                          ERC721TokenReceiver.onERC721Received.selector,
                                      "UNSAFE_RECIPIENT"
                                  );
                              }
                              function _safeMint(
                                  address to,
                                  uint256 id,
                                  bytes memory data
                              ) internal virtual {
                                  _mint(to, id);
                                  require(
                                      to.code.length == 0 ||
                                          ERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, data) ==
                                          ERC721TokenReceiver.onERC721Received.selector,
                                      "UNSAFE_RECIPIENT"
                                  );
                              }
                          }
                          /// @notice A generic interface for a contract which properly accepts ERC721 tokens.
                          /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC721.sol)
                          abstract contract ERC721TokenReceiver {
                              function onERC721Received(
                                  address,
                                  address,
                                  uint256,
                                  bytes calldata
                              ) external virtual returns (bytes4) {
                                  return ERC721TokenReceiver.onERC721Received.selector;
                              }
                          }
                          

                          File 7 of 10: BlurPool
                          // SPDX-License-Identifier: MIT
                          pragma solidity 0.8.17;
                          import "lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/UUPSUpgradeable.sol";
                          import "lib/openzeppelin-contracts-upgradeable/contracts/access/OwnableUpgradeable.sol";
                          import "./interfaces/IBlurPool.sol";
                          /**
                           * @title BlurPool
                           * @dev ETH pool; funds can only be transferred by Exchange, ExchangeV2, Swap or Blend
                           */
                          contract BlurPool is IBlurPool, OwnableUpgradeable, UUPSUpgradeable {
                              address private immutable EXCHANGE;
                              address private immutable EXCHANGE_V2;
                              address private immutable SWAP;
                              address private immutable BLEND;
                              mapping(address => uint256) private _balances;
                              string public constant name = 'Blur Pool';
                              string constant symbol = '';
                              // required by the OZ UUPS module
                              function _authorizeUpgrade(address) internal override onlyOwner {}
                              constructor(address exchange, address exchangeV2, address swap, address blend) {
                                  _disableInitializers();
                                  EXCHANGE = exchange;
                                  EXCHANGE_V2 = exchangeV2;
                                  SWAP = swap;
                                  BLEND = blend;
                              }
                              /* Constructor (for ERC1967) */
                              function initialize() external initializer {
                                  __Ownable_init();
                              }
                              function decimals() external pure returns (uint8) {
                                  return 18;
                              }
                              function totalSupply() external view returns (uint256) {
                                  return address(this).balance;
                              }
                              function balanceOf(address user) external view returns (uint256) {
                                  return _balances[user];
                              }
                              /**
                               * @dev receive deposit function
                               */
                              receive() external payable {
                                  deposit();
                              }
                              /**
                               * @dev deposit ETH into pool
                               */
                              function deposit() public payable {
                                  _balances[msg.sender] += msg.value;
                                  emit Transfer(address(0), msg.sender, msg.value);
                              }
                              /**
                               * @dev deposit ETH into pool on behalf of user
                               * @param user Address to deposit to
                               */
                              function deposit(address user) public payable {
                                  if (msg.sender != BLEND && msg.sender != EXCHANGE_V2) {
                                      revert('Unauthorized deposit');
                                  }
                                  _balances[user] += msg.value;
                                  emit Transfer(address(0), user, msg.value);
                              }
                              /**
                               * @dev withdraw ETH from pool
                               * @param amount Amount to withdraw
                               */
                              function withdraw(uint256 amount) external {
                                  uint256 balance = _balances[msg.sender];
                                  require(balance >= amount, "Insufficient funds");
                                  unchecked {
                                      _balances[msg.sender] = balance - amount;
                                  }
                                  (bool success,) = payable(msg.sender).call{value: amount}("");
                                  require(success, "Transfer failed");
                                  emit Transfer(msg.sender, address(0), amount);
                              }
                              /**
                               * @dev withdraw ETH from pool on behalf of user; only callable by Blend
                               * @param from Address to withdraw from
                               * @param to Address to withdraw to
                               * @param amount Amount to withdraw
                               */
                              function withdrawFrom(address from, address to, uint256 amount) external {
                                  if (msg.sender != BLEND && msg.sender != EXCHANGE_V2) {
                                      revert('Unauthorized transfer');
                                  }
                                  uint256 balance = _balances[from];
                                  require(balance >= amount, "Insufficient balance");
                                  unchecked {
                                      _balances[from] = balance - amount;
                                  }
                                  (bool success,) = payable(to).call{value: amount}("");
                                  require(success, "Transfer failed");
                                  emit Transfer(from, address(0), amount);
                              }
                              /**
                               * @dev transferFrom Transfer balances within pool; only callable by Swap, Exchange, and Blend
                               * @param from Pool fund sender
                               * @param to Pool fund recipient
                               * @param amount Amount to transfer
                               */
                              function transferFrom(address from, address to, uint256 amount)
                                  external
                                  returns (bool)
                              {
                                  if (
                                      msg.sender != EXCHANGE &&
                                      msg.sender != EXCHANGE_V2 &&
                                      msg.sender != SWAP &&
                                      msg.sender != BLEND
                                  ) {
                                      revert('Unauthorized transfer');
                                  }
                                  _transfer(from, to, amount);
                                  return true;
                              }
                              function _transfer(address from, address to, uint256 amount) private {
                                  require(to != address(0), "Cannot transfer to 0 address");
                                  uint256 balance = _balances[from];
                                  require(balance >= amount, "Insufficient balance");
                                  unchecked {
                                      _balances[from] = balance - amount;
                                  }
                                  _balances[to] += amount;
                                  emit Transfer(from, to, amount);
                              }
                          }
                          // SPDX-License-Identifier: MIT
                          // OpenZeppelin Contracts (last updated v4.8.0) (proxy/utils/UUPSUpgradeable.sol)
                          pragma solidity ^0.8.0;
                          import "../../interfaces/draft-IERC1822Upgradeable.sol";
                          import "../ERC1967/ERC1967UpgradeUpgradeable.sol";
                          import "./Initializable.sol";
                          /**
                           * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an
                           * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.
                           *
                           * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is
                           * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing
                           * `UUPSUpgradeable` with a custom implementation of upgrades.
                           *
                           * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.
                           *
                           * _Available since v4.1._
                           */
                          abstract contract UUPSUpgradeable is Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable {
                              function __UUPSUpgradeable_init() internal onlyInitializing {
                              }
                              function __UUPSUpgradeable_init_unchained() internal onlyInitializing {
                              }
                              /// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment
                              address private immutable __self = address(this);
                              /**
                               * @dev Check that the execution is being performed through a delegatecall call and that the execution context is
                               * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case
                               * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a
                               * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to
                               * fail.
                               */
                              modifier onlyProxy() {
                                  require(address(this) != __self, "Function must be called through delegatecall");
                                  require(_getImplementation() == __self, "Function must be called through active proxy");
                                  _;
                              }
                              /**
                               * @dev Check that the execution is not being performed through a delegate call. This allows a function to be
                               * callable on the implementing contract but not through proxies.
                               */
                              modifier notDelegated() {
                                  require(address(this) == __self, "UUPSUpgradeable: must not be called through delegatecall");
                                  _;
                              }
                              /**
                               * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the
                               * implementation. It is used to validate the implementation's compatibility when performing an upgrade.
                               *
                               * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
                               * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
                               * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.
                               */
                              function proxiableUUID() external view virtual override notDelegated returns (bytes32) {
                                  return _IMPLEMENTATION_SLOT;
                              }
                              /**
                               * @dev Upgrade the implementation of the proxy to `newImplementation`.
                               *
                               * Calls {_authorizeUpgrade}.
                               *
                               * Emits an {Upgraded} event.
                               */
                              function upgradeTo(address newImplementation) external virtual onlyProxy {
                                  _authorizeUpgrade(newImplementation);
                                  _upgradeToAndCallUUPS(newImplementation, new bytes(0), false);
                              }
                              /**
                               * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call
                               * encoded in `data`.
                               *
                               * Calls {_authorizeUpgrade}.
                               *
                               * Emits an {Upgraded} event.
                               */
                              function upgradeToAndCall(address newImplementation, bytes memory data) external payable virtual onlyProxy {
                                  _authorizeUpgrade(newImplementation);
                                  _upgradeToAndCallUUPS(newImplementation, data, true);
                              }
                              /**
                               * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by
                               * {upgradeTo} and {upgradeToAndCall}.
                               *
                               * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.
                               *
                               * ```solidity
                               * function _authorizeUpgrade(address) internal override onlyOwner {}
                               * ```
                               */
                              function _authorizeUpgrade(address newImplementation) internal virtual;
                              /**
                               * @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.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
                          pragma solidity ^0.8.0;
                          interface IBlurPool {
                              event Transfer(address indexed from, address indexed to, uint256 amount);
                              function initialize() external;
                              function decimals() external pure returns (uint8);
                              function totalSupply() external view returns (uint256);
                              function balanceOf(address user) external view returns (uint256);
                              function deposit() external payable;
                              function deposit(address user) external payable;
                              function withdraw(uint256 amount) external;
                              function withdrawFrom(address from, address to, uint256 amount) external;
                              function transferFrom(address from, address to, uint256 amount) external returns (bool);
                          }
                          // SPDX-License-Identifier: MIT
                          // OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)
                          pragma solidity ^0.8.0;
                          /**
                           * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
                           * proxy whose upgrades are fully controlled by the current implementation.
                           */
                          interface IERC1822ProxiableUpgradeable {
                              /**
                               * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
                               * address.
                               *
                               * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
                               * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
                               * function revert if invoked through a proxy.
                               */
                              function proxiableUUID() external view returns (bytes32);
                          }
                          // SPDX-License-Identifier: MIT
                          // OpenZeppelin Contracts (last updated v4.8.3) (proxy/ERC1967/ERC1967Upgrade.sol)
                          pragma solidity ^0.8.2;
                          import "../beacon/IBeaconUpgradeable.sol";
                          import "../../interfaces/IERC1967Upgradeable.sol";
                          import "../../interfaces/draft-IERC1822Upgradeable.sol";
                          import "../../utils/AddressUpgradeable.sol";
                          import "../../utils/StorageSlotUpgradeable.sol";
                          import "../utils/Initializable.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 ERC1967UpgradeUpgradeable is Initializable, IERC1967Upgradeable {
                              function __ERC1967Upgrade_init() internal onlyInitializing {
                              }
                              function __ERC1967Upgrade_init_unchained() internal onlyInitializing {
                              }
                              // 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 Returns the current implementation address.
                               */
                              function _getImplementation() internal view returns (address) {
                                  return StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value;
                              }
                              /**
                               * @dev Stores a new address in the EIP1967 implementation slot.
                               */
                              function _setImplementation(address newImplementation) private {
                                  require(AddressUpgradeable.isContract(newImplementation), "ERC1967: new implementation is not a contract");
                                  StorageSlotUpgradeable.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 {
                                  _upgradeTo(newImplementation);
                                  if (data.length > 0 || forceCall) {
                                      _functionDelegateCall(newImplementation, data);
                                  }
                              }
                              /**
                               * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
                               *
                               * Emits an {Upgraded} event.
                               */
                              function _upgradeToAndCallUUPS(
                                  address newImplementation,
                                  bytes memory data,
                                  bool forceCall
                              ) internal {
                                  // Upgrades from old implementations will perform a rollback test. This test requires the new
                                  // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
                                  // this special case will break upgrade paths from old UUPS implementation to new ones.
                                  if (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) {
                                      _setImplementation(newImplementation);
                                  } else {
                                      try IERC1822ProxiableUpgradeable(newImplementation).proxiableUUID() returns (bytes32 slot) {
                                          require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
                                      } catch {
                                          revert("ERC1967Upgrade: new implementation is not UUPS");
                                      }
                                      _upgradeToAndCall(newImplementation, data, forceCall);
                                  }
                              }
                              /**
                               * @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 Returns the current admin.
                               */
                              function _getAdmin() internal view returns (address) {
                                  return StorageSlotUpgradeable.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");
                                  StorageSlotUpgradeable.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 Returns the current beacon.
                               */
                              function _getBeacon() internal view returns (address) {
                                  return StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value;
                              }
                              /**
                               * @dev Stores a new beacon in the EIP1967 beacon slot.
                               */
                              function _setBeacon(address newBeacon) private {
                                  require(AddressUpgradeable.isContract(newBeacon), "ERC1967: new beacon is not a contract");
                                  require(
                                      AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()),
                                      "ERC1967: beacon implementation is not a contract"
                                  );
                                  StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value = newBeacon;
                              }
                              /**
                               * @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) {
                                      _functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data);
                                  }
                              }
                              /**
                               * @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) private returns (bytes memory) {
                                  require(AddressUpgradeable.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 AddressUpgradeable.verifyCallResult(success, returndata, "Address: low-level delegate call failed");
                              }
                              /**
                               * @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.1) (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 Returns the highest version that has been initialized. See {reinitializer}.
                               */
                              function _getInitializedVersion() internal view returns (uint8) {
                                  return _initialized;
                              }
                              /**
                               * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
                               */
                              function _isInitializing() internal view returns (bool) {
                                  return _initializing;
                              }
                          }
                          // SPDX-License-Identifier: MIT
                          // OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)
                          pragma solidity ^0.8.0;
                          /**
                           * @dev This is the interface that {BeaconProxy} expects of its beacon.
                           */
                          interface IBeaconUpgradeable {
                              /**
                               * @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
                          // OpenZeppelin Contracts (last updated v4.8.3) (interfaces/IERC1967.sol)
                          pragma solidity ^0.8.0;
                          /**
                           * @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC.
                           *
                           * _Available since v4.9._
                           */
                          interface IERC1967Upgradeable {
                              /**
                               * @dev Emitted when the implementation is upgraded.
                               */
                              event Upgraded(address indexed implementation);
                              /**
                               * @dev Emitted when the admin account has changed.
                               */
                              event AdminChanged(address previousAdmin, address newAdmin);
                              /**
                               * @dev Emitted when the beacon is changed.
                               */
                              event BeaconUpgraded(address indexed beacon);
                          }
                          // 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 (last updated v4.7.0) (utils/StorageSlot.sol)
                          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 StorageSlotUpgradeable {
                              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) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r.slot := slot
                                  }
                              }
                              /**
                               * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
                               */
                              function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r.slot := slot
                                  }
                              }
                              /**
                               * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
                               */
                              function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r.slot := slot
                                  }
                              }
                              /**
                               * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
                               */
                              function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r.slot := slot
                                  }
                              }
                          }
                          // 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;
                          }
                          

                          File 8 of 10: 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);
                          }
                          

                          File 9 of 10: BlurExchangeV2
                          // SPDX-License-Identifier: MIT
                          pragma solidity 0.8.17;
                          import { Ownable2StepUpgradeable } from "lib/openzeppelin-contracts-upgradeable/contracts/access/Ownable2StepUpgradeable.sol";
                          import { UUPSUpgradeable } from "lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/UUPSUpgradeable.sol";
                          import { Executor } from "./Executor.sol";
                          import "./lib/Constants.sol";
                          import {
                              TakeAsk,
                              TakeBid,
                              TakeAskSingle,
                              TakeBidSingle,
                              Order,
                              Exchange,
                              Fees,
                              FeeRate,
                              AssetType,
                              OrderType,
                              Transfer,
                              FungibleTransfers,
                              StateUpdate,
                              AtomicExecution,
                              Cancel,
                              Listing
                          } from "./lib/Structs.sol";
                          import { IBlurExchangeV2 } from "./interfaces/IBlurExchangeV2.sol";
                          import { ReentrancyGuardUpgradeable } from "./lib/ReentrancyGuardUpgradeable.sol";
                          contract BlurExchangeV2 is
                              IBlurExchangeV2,
                              Ownable2StepUpgradeable,
                              UUPSUpgradeable,
                              ReentrancyGuardUpgradeable,
                              Executor
                          {
                              address public governor;
                              // required by the OZ UUPS module
                              function _authorizeUpgrade(address) internal override onlyOwner {}
                              constructor(address delegate, address pool, address proxy) Executor(delegate, pool, proxy) {
                                  _disableInitializers();
                              }
                              function initialize() external initializer {
                                  __UUPSUpgradeable_init();
                                  __Ownable_init();
                                  __Reentrancy_init();
                                  verifyDomain();
                              }
                              modifier onlyGovernor() {
                                  if (msg.sender != governor) {
                                      revert Unauthorized();
                                  }
                                  _;
                              }
                              /**
                               * @notice Governor only function to set the protocol fee rate and recipient
                               * @param recipient Protocol fee recipient
                               * @param rate Protocol fee rate
                               */
                              function setProtocolFee(address recipient, uint16 rate) external onlyGovernor {
                                  if (rate > _MAX_PROTOCOL_FEE_RATE) {
                                      revert ProtocolFeeTooHigh();
                                  }
                                  protocolFee = FeeRate(recipient, rate);
                                  emit NewProtocolFee(recipient, rate);
                              }
                              /**
                               * @notice Admin only function to set the governor of the exchange
                               * @param _governor Address of governor to set
                               */
                              function setGovernor(address _governor) external onlyOwner {
                                  governor = _governor;
                                  emit NewGovernor(_governor);
                              }
                              /**
                               * @notice Admin only function to grant or revoke the approval of an oracle
                               * @param oracle Address to set approval of
                               * @param approved If the oracle should be approved or not
                               */
                              function setOracle(address oracle, bool approved) external onlyOwner {
                                  if (approved) {
                                      oracles[oracle] = 1;
                                  } else {
                                      oracles[oracle] = 0;
                                  }
                                  emit SetOracle(oracle, approved);
                              }
                              /**
                               * @notice Admin only function to set the block range
                               * @param _blockRange Block range that oracle signatures are valid for
                               */
                              function setBlockRange(uint256 _blockRange) external onlyOwner {
                                  blockRange = _blockRange;
                                  emit NewBlockRange(_blockRange);
                              }
                              /**
                               * @notice Cancel listings by recording their fulfillment
                               * @param cancels List of cancels to execute
                               */
                              function cancelTrades(Cancel[] memory cancels) external {
                                  uint256 cancelsLength = cancels.length;
                                  for (uint256 i; i < cancelsLength; ) {
                                      Cancel memory cancel = cancels[i];
                                      amountTaken[msg.sender][cancel.hash][cancel.index] += cancel.amount;
                                      emit CancelTrade(msg.sender, cancel.hash, cancel.index, cancel.amount);
                                      unchecked {
                                          ++i;
                                      }
                                  }
                              }
                              /**
                               * @notice Cancels all orders by incrementing caller nonce
                               */
                              function incrementNonce() external {
                                  emit NonceIncremented(msg.sender, ++nonces[msg.sender]);
                              }
                              /*//////////////////////////////////////////////////////////////
                                                    EXECUTION WRAPPERS
                              //////////////////////////////////////////////////////////////*/
                              /**
                               * @notice Wrapper of _takeAsk that verifies an oracle signature of the calldata before executing
                               * @param inputs Inputs for _takeAsk
                               * @param oracleSignature Oracle signature of inputs
                               */
                              function takeAsk(
                                  TakeAsk memory inputs,
                                  bytes calldata oracleSignature
                              )
                                  public
                                  payable
                                  nonReentrant
                                  verifyOracleSignature(_hashCalldata(msg.sender), oracleSignature)
                              {
                                  _takeAsk(
                                      inputs.orders,
                                      inputs.exchanges,
                                      inputs.takerFee,
                                      inputs.signatures,
                                      inputs.tokenRecipient
                                  );
                              }
                              /**
                               * @notice Wrapper of _takeBid that verifies an oracle signature of the calldata before executing
                               * @param inputs Inputs for _takeBid
                               * @param oracleSignature Oracle signature of inputs
                               */
                              function takeBid(
                                  TakeBid memory inputs,
                                  bytes calldata oracleSignature
                              ) public verifyOracleSignature(_hashCalldata(msg.sender), oracleSignature) {
                                  _takeBid(inputs.orders, inputs.exchanges, inputs.takerFee, inputs.signatures);
                              }
                              /**
                               * @notice Wrapper of _takeAskSingle that verifies an oracle signature of the calldata before executing
                               * @param inputs Inputs for _takeAskSingle
                               * @param oracleSignature Oracle signature of inputs
                               */
                              function takeAskSingle(
                                  TakeAskSingle memory inputs,
                                  bytes calldata oracleSignature
                              )
                                  public
                                  payable
                                  nonReentrant
                                  verifyOracleSignature(_hashCalldata(msg.sender), oracleSignature)
                              {
                                  _takeAskSingle(
                                      inputs.order,
                                      inputs.exchange,
                                      inputs.takerFee,
                                      inputs.signature,
                                      inputs.tokenRecipient
                                  );
                              }
                              /**
                               * @notice Wrapper of _takeBidSingle that verifies an oracle signature of the calldata before executing
                               * @param inputs Inputs for _takeBidSingle
                               * @param oracleSignature Oracle signature of inputs
                               */
                              function takeBidSingle(
                                  TakeBidSingle memory inputs,
                                  bytes calldata oracleSignature
                              ) external verifyOracleSignature(_hashCalldata(msg.sender), oracleSignature) {
                                  _takeBidSingle(inputs.order, inputs.exchange, inputs.takerFee, inputs.signature);
                              }
                              /*//////////////////////////////////////////////////////////////
                                                  EXECUTION POOL WRAPPERS
                              //////////////////////////////////////////////////////////////*/
                              /**
                               * @notice Wrapper of takeAskSingle that withdraws ETH from the caller's pool balance prior to executing
                               * @param inputs Inputs for takeAskSingle
                               * @param oracleSignature Oracle signature of inputs
                               * @param amountToWithdraw Amount of ETH to withdraw from the pool
                               */
                              function takeAskSinglePool(
                                  TakeAskSingle memory inputs,
                                  bytes calldata oracleSignature,
                                  uint256 amountToWithdraw
                              ) external payable {
                                  _withdrawFromPool(msg.sender, amountToWithdraw);
                                  takeAskSingle(inputs, oracleSignature);
                              }
                              /**
                               * @notice Wrapper of takeAsk that withdraws ETH from the caller's pool balance prior to executing
                               * @param inputs Inputs for takeAsk
                               * @param oracleSignature Oracle signature of inputs
                               * @param amountToWithdraw Amount of ETH to withdraw from the pool
                               */
                              function takeAskPool(
                                  TakeAsk memory inputs,
                                  bytes calldata oracleSignature,
                                  uint256 amountToWithdraw
                              ) external payable {
                                  _withdrawFromPool(msg.sender, amountToWithdraw);
                                  takeAsk(inputs, oracleSignature);
                              }
                              /*//////////////////////////////////////////////////////////////
                                                    EXECUTION FUNCTIONS
                              //////////////////////////////////////////////////////////////*/
                              /**
                               * @notice Take a single ask
                               * @param order Order of listing to fulfill
                               * @param exchange Exchange struct indicating the listing to take and the parameters to match it with
                               * @param takerFee Taker fee to be taken
                               * @param signature Order signature
                               * @param tokenRecipient Address to receive the token transfer
                               */
                              function _takeAskSingle(
                                  Order memory order,
                                  Exchange memory exchange,
                                  FeeRate memory takerFee,
                                  bytes memory signature,
                                  address tokenRecipient
                              ) internal {
                                  Fees memory fees = Fees(protocolFee, takerFee);
                                  Listing memory listing = exchange.listing;
                                  uint256 takerAmount = exchange.taker.amount;
                                  /* Validate the order and listing, revert if not. */
                                  if (!_validateOrderAndListing(order, OrderType.ASK, exchange, signature, fees)) {
                                      revert InvalidOrder();
                                  }
                                  /* Create single execution batch and insert the transfer. */
                                  bytes memory executionBatch = _initializeSingleExecution(
                                      order,
                                      OrderType.ASK,
                                      listing.tokenId,
                                      takerAmount,
                                      tokenRecipient
                                  );
                                  /* Set the fulfillment of the order. */
                                  unchecked {
                                      amountTaken[order.trader][bytes32(order.salt)][listing.index] += takerAmount;
                                  }
                                  /* Execute the token transfers, revert if not successful. */
                                  {
                                      bool[] memory successfulTransfers = _executeNonfungibleTransfers(executionBatch, 1);
                                      if (!successfulTransfers[0]) {
                                          revert TokenTransferFailed();
                                      }
                                  }
                                  (
                                      uint256 totalPrice,
                                      uint256 protocolFeeAmount,
                                      uint256 makerFeeAmount,
                                      uint256 takerFeeAmount
                                  ) = _computeFees(listing.price, takerAmount, order.makerFee, fees);
                                  /* If there are insufficient funds to cover the price with the fees, revert. */
                                  unchecked {
                                      if (address(this).balance < totalPrice + takerFeeAmount) {
                                          revert InsufficientFunds();
                                      }
                                  }
                                  /* Execute ETH transfers. */
                                  _transferETH(fees.protocolFee.recipient, protocolFeeAmount);
                                  _transferETH(fees.takerFee.recipient, takerFeeAmount);
                                  _transferETH(order.makerFee.recipient, makerFeeAmount);
                                  unchecked {
                                      _transferETH(order.trader, totalPrice - makerFeeAmount - protocolFeeAmount);
                                  }
                                  _emitExecutionEvent(executionBatch, order, listing.index, totalPrice, fees, OrderType.ASK);
                                  /* Return dust. */
                                  _transferETH(msg.sender, address(this).balance);
                              }
                              /**
                               * @notice Take a single bid
                               * @param order Order of listing to fulfill
                               * @param exchange Exchange struct indicating the listing to take and the parameters to match it with
                               * @param takerFee Taker fee to be taken
                               * @param signature Order signature
                               */
                              function _takeBidSingle(
                                  Order memory order,
                                  Exchange memory exchange,
                                  FeeRate memory takerFee,
                                  bytes memory signature
                              ) internal {
                                  Fees memory fees = Fees(protocolFee, takerFee);
                                  Listing memory listing = exchange.listing;
                                  uint256 takerAmount = exchange.taker.amount;
                                  /* Validate the order and listing, revert if not. */
                                  if (!_validateOrderAndListing(order, OrderType.BID, exchange, signature, fees)) {
                                      revert InvalidOrder();
                                  }
                                  /* Create single execution batch and insert the transfer. */
                                  bytes memory executionBatch = _initializeSingleExecution(
                                      order,
                                      OrderType.BID,
                                      exchange.taker.tokenId,
                                      takerAmount,
                                      msg.sender
                                  );
                                  /* Execute the token transfers, revert if not successful. */
                                  {
                                      bool[] memory successfulTransfers = _executeNonfungibleTransfers(executionBatch, 1);
                                      if (!successfulTransfers[0]) {
                                          revert TokenTransferFailed();
                                      }
                                  }
                                  (
                                      uint256 totalPrice,
                                      uint256 protocolFeeAmount,
                                      uint256 makerFeeAmount,
                                      uint256 takerFeeAmount
                                  ) = _computeFees(listing.price, takerAmount, order.makerFee, fees);
                                  /* Execute pool transfers and set the fulfillment of the order. */
                                  address trader = order.trader;
                                  _transferPool(trader, order.makerFee.recipient, makerFeeAmount);
                                  _transferPool(trader, fees.takerFee.recipient, takerFeeAmount);
                                  _transferPool(trader, fees.protocolFee.recipient, protocolFeeAmount);
                                  unchecked {
                                      _transferPool(trader, msg.sender, totalPrice - takerFeeAmount - protocolFeeAmount);
                                      amountTaken[trader][bytes32(order.salt)][listing.index] += exchange.taker.amount;
                                  }
                                  _emitExecutionEvent(executionBatch, order, listing.index, totalPrice, fees, OrderType.BID);
                              }
                              /**
                               * @notice Take multiple asks; efficiently verifying and executing the transfers in bulk
                               * @param orders List of orders
                               * @param exchanges List of exchanges indicating the listing to take and the parameters to match it with
                               * @param takerFee Taker fee to be taken on each exchange
                               * @param signatures Bytes array of order signatures
                               * @param tokenRecipient Address to receive the tokens purchased
                               */
                              function _takeAsk(
                                  Order[] memory orders,
                                  Exchange[] memory exchanges,
                                  FeeRate memory takerFee,
                                  bytes memory signatures,
                                  address tokenRecipient
                              ) internal {
                                  Fees memory fees = Fees(protocolFee, takerFee);
                                  /**
                                   * Validate all the orders potentially used in the execution and
                                   * initialize the arrays for pending fulfillments.
                                   */
                                  (bool[] memory validOrders, uint256[][] memory pendingAmountTaken) = _validateOrders(
                                      orders,
                                      OrderType.ASK,
                                      signatures,
                                      fees
                                  );
                                  uint256 exchangesLength = exchanges.length;
                                  /* Initialize the execution batch structs. */
                                  (
                                      bytes memory executionBatch,
                                      FungibleTransfers memory fungibleTransfers
                                  ) = _initializeBatch(exchangesLength, OrderType.ASK, tokenRecipient);
                                  Order memory order;
                                  Exchange memory exchange;
                                  uint256 remainingETH = address(this).balance;
                                  for (uint256 i; i < exchangesLength; ) {
                                      exchange = exchanges[i];
                                      order = orders[exchange.index];
                                      /* Check the listing and exchange is valid and its parent order has already been validated. */
                                      if (
                                          _validateListingFromBatch(
                                              order,
                                              OrderType.ASK,
                                              exchange,
                                              validOrders,
                                              pendingAmountTaken
                                          )
                                      ) {
                                          /* Insert the transfers into the batch. */
                                          bool inserted;
                                          (remainingETH, inserted) = _insertExecutionAsk(
                                              executionBatch,
                                              fungibleTransfers,
                                              order,
                                              exchange,
                                              fees,
                                              remainingETH
                                          );
                                          if (inserted) {
                                              unchecked {
                                                  pendingAmountTaken[exchange.index][exchange.listing.index] += exchange
                                                      .taker
                                                      .amount;
                                              }
                                          }
                                      }
                                      unchecked {
                                          ++i;
                                      }
                                  }
                                  /* Execute all transfers. */
                                  _executeBatchTransfer(executionBatch, fungibleTransfers, fees, OrderType.ASK);
                                  /* Return dust. */
                                  _transferETH(msg.sender, address(this).balance);
                              }
                              /**
                               * @notice Take multiple bids; efficiently verifying and executing the transfers in bulk
                               * @param orders List of orders
                               * @param exchanges List of exchanges indicating the listing to take and the parameters to match it with
                               * @param takerFee Taker fee to be taken on each exchange
                               * @param signatures Bytes array of order signatures
                               */
                              function _takeBid(
                                  Order[] memory orders,
                                  Exchange[] memory exchanges,
                                  FeeRate memory takerFee,
                                  bytes memory signatures
                              ) internal {
                                  Fees memory fees = Fees(protocolFee, takerFee);
                                  /**
                                   * Validate all the orders potentially used in the execution and
                                   * initialize the arrays for pending fulfillments.
                                   */
                                  (bool[] memory validOrders, uint256[][] memory pendingAmountTaken) = _validateOrders(
                                      orders,
                                      OrderType.BID,
                                      signatures,
                                      fees
                                  );
                                  uint256 exchangesLength = exchanges.length;
                                  /* Initialize the execution batch structs. */
                                  (
                                      bytes memory executionBatch,
                                      FungibleTransfers memory fungibleTransfers
                                  ) = _initializeBatch(exchangesLength, OrderType.BID, msg.sender);
                                  Order memory order;
                                  Exchange memory exchange;
                                  for (uint256 i; i < exchangesLength; ) {
                                      exchange = exchanges[i];
                                      order = orders[exchange.index];
                                      /* Check the listing and exchange is valid and its parent order has already been validated. */
                                      if (
                                          _validateListingFromBatch(
                                              order,
                                              OrderType.BID,
                                              exchange,
                                              validOrders,
                                              pendingAmountTaken
                                          )
                                      ) {
                                          /* Insert the transfers into the batch. */
                                          _insertExecutionBid(executionBatch, fungibleTransfers, order, exchange, fees);
                                          /* Record the pending fulfillment. */
                                          unchecked {
                                              pendingAmountTaken[exchange.index][exchange.listing.index] += exchange
                                                  .taker
                                                  .amount;
                                          }
                                      }
                                      unchecked {
                                          ++i;
                                      }
                                  }
                                  /* Execute all transfers. */
                                  _executeBatchTransfer(executionBatch, fungibleTransfers, fees, OrderType.BID);
                              }
                              /*//////////////////////////////////////////////////////////////
                                                    EXECUTION HELPERS
                              //////////////////////////////////////////////////////////////*/
                              /**
                               * @notice Initialize the ExecutionBatch and FungibleTransfers objects for bulk execution
                               * @param exchangesLength Number of exchanges
                               * @param orderType Order type
                               * @param taker Order taker address
                               */
                              function _initializeBatch(
                                  uint256 exchangesLength,
                                  OrderType orderType,
                                  address taker
                              )
                                  internal
                                  pure
                                  returns (bytes memory executionBatch, FungibleTransfers memory fungibleTransfers)
                              {
                                  /* Initialize the batch. Constructing it manually in calldata packing allows for cheaper delegate execution. */
                                  uint256 arrayLength = Transfer_size * exchangesLength + One_word;
                                  uint256 executionBatchLength = ExecutionBatch_base_size + arrayLength;
                                  executionBatch = new bytes(executionBatchLength);
                                  assembly {
                                      let calldataPointer := add(executionBatch, ExecutionBatch_calldata_offset)
                                      mstore(add(calldataPointer, ExecutionBatch_taker_offset), taker)
                                      mstore(add(calldataPointer, ExecutionBatch_orderType_offset), orderType)
                                      mstore(add(calldataPointer, ExecutionBatch_transfers_pointer_offset), ExecutionBatch_transfers_offset) // set the transfers pointer
                                      mstore(add(calldataPointer, ExecutionBatch_transfers_offset), exchangesLength) // set the length of the transfers array
                                  }
                                  /* Initialize the fungible transfers object. */
                                  AtomicExecution[] memory executions = new AtomicExecution[](exchangesLength);
                                  address[] memory feeRecipients = new address[](exchangesLength);
                                  address[] memory makers = new address[](exchangesLength);
                                  uint256[] memory makerTransfers = new uint256[](exchangesLength);
                                  uint256[] memory feeTransfers = new uint256[](exchangesLength);
                                  fungibleTransfers = FungibleTransfers({
                                      totalProtocolFee: 0,
                                      totalSellerTransfer: 0,
                                      totalTakerFee: 0,
                                      feeRecipientId: 0,
                                      feeRecipients: feeRecipients,
                                      makerId: 0,
                                      makers: makers,
                                      feeTransfers: feeTransfers,
                                      makerTransfers: makerTransfers,
                                      executions: executions
                                  });
                              }
                              /**
                               * @notice Initialize the ExecutionBatch object for a single execution
                               * @param order Order to take a Listing from
                               * @param orderType Order type
                               * @param tokenId Token id
                               * @param amount ERC721/ERC1155 amount
                               * @param taker Order taker address
                               */
                              function _initializeSingleExecution(
                                  Order memory order,
                                  OrderType orderType,
                                  uint256 tokenId,
                                  uint256 amount,
                                  address taker
                              ) internal pure returns (bytes memory executionBatch) {
                                  /* Initialize the batch. Constructing it manually in calldata packing allows for cheaper delegate execution. */
                                  uint256 arrayLength = Transfer_size + One_word;
                                  uint256 executionBatchLength = ExecutionBatch_base_size + arrayLength;
                                  executionBatch = new bytes(executionBatchLength);
                                  assembly {
                                      let calldataPointer := add(executionBatch, ExecutionBatch_calldata_offset)
                                      mstore(add(calldataPointer, ExecutionBatch_taker_offset), taker)
                                      mstore(add(calldataPointer, ExecutionBatch_orderType_offset), orderType)
                                      mstore(add(calldataPointer, ExecutionBatch_transfers_pointer_offset), ExecutionBatch_transfers_offset) // set the transfers pointer
                                      mstore(add(calldataPointer, ExecutionBatch_transfers_offset), 1) // set the length of the transfers array
                                  }
                                  /* Insert the transfer into the batch. */
                                  _insertNonfungibleTransfer(executionBatch, order, tokenId, amount);
                              }
                          }
                          // SPDX-License-Identifier: MIT
                          // OpenZeppelin Contracts (last updated v4.8.0) (access/Ownable2Step.sol)
                          pragma solidity ^0.8.0;
                          import "./OwnableUpgradeable.sol";
                          import "../proxy/utils/Initializable.sol";
                          /**
                           * @dev Contract module which provides 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} and {acceptOwnership}.
                           *
                           * This module is used through inheritance. It will make available all functions
                           * from parent (Ownable).
                           */
                          abstract contract Ownable2StepUpgradeable is Initializable, OwnableUpgradeable {
                              function __Ownable2Step_init() internal onlyInitializing {
                                  __Ownable_init_unchained();
                              }
                              function __Ownable2Step_init_unchained() internal onlyInitializing {
                              }
                              address private _pendingOwner;
                              event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);
                              /**
                               * @dev Returns the address of the pending owner.
                               */
                              function pendingOwner() public view virtual returns (address) {
                                  return _pendingOwner;
                              }
                              /**
                               * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.
                               * Can only be called by the current owner.
                               */
                              function transferOwnership(address newOwner) public virtual override onlyOwner {
                                  _pendingOwner = newOwner;
                                  emit OwnershipTransferStarted(owner(), newOwner);
                              }
                              /**
                               * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.
                               * Internal function without access restriction.
                               */
                              function _transferOwnership(address newOwner) internal virtual override {
                                  delete _pendingOwner;
                                  super._transferOwnership(newOwner);
                              }
                              /**
                               * @dev The new owner accepts the ownership transfer.
                               */
                              function acceptOwnership() external {
                                  address sender = _msgSender();
                                  require(pendingOwner() == sender, "Ownable2Step: caller is not the new owner");
                                  _transferOwnership(sender);
                              }
                              /**
                               * @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/UUPSUpgradeable.sol)
                          pragma solidity ^0.8.0;
                          import "../../interfaces/draft-IERC1822Upgradeable.sol";
                          import "../ERC1967/ERC1967UpgradeUpgradeable.sol";
                          import "./Initializable.sol";
                          /**
                           * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an
                           * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.
                           *
                           * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is
                           * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing
                           * `UUPSUpgradeable` with a custom implementation of upgrades.
                           *
                           * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.
                           *
                           * _Available since v4.1._
                           */
                          abstract contract UUPSUpgradeable is Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable {
                              function __UUPSUpgradeable_init() internal onlyInitializing {
                              }
                              function __UUPSUpgradeable_init_unchained() internal onlyInitializing {
                              }
                              /// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment
                              address private immutable __self = address(this);
                              /**
                               * @dev Check that the execution is being performed through a delegatecall call and that the execution context is
                               * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case
                               * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a
                               * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to
                               * fail.
                               */
                              modifier onlyProxy() {
                                  require(address(this) != __self, "Function must be called through delegatecall");
                                  require(_getImplementation() == __self, "Function must be called through active proxy");
                                  _;
                              }
                              /**
                               * @dev Check that the execution is not being performed through a delegate call. This allows a function to be
                               * callable on the implementing contract but not through proxies.
                               */
                              modifier notDelegated() {
                                  require(address(this) == __self, "UUPSUpgradeable: must not be called through delegatecall");
                                  _;
                              }
                              /**
                               * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the
                               * implementation. It is used to validate the implementation's compatibility when performing an upgrade.
                               *
                               * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
                               * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
                               * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.
                               */
                              function proxiableUUID() external view virtual override notDelegated returns (bytes32) {
                                  return _IMPLEMENTATION_SLOT;
                              }
                              /**
                               * @dev Upgrade the implementation of the proxy to `newImplementation`.
                               *
                               * Calls {_authorizeUpgrade}.
                               *
                               * Emits an {Upgraded} event.
                               */
                              function upgradeTo(address newImplementation) external virtual onlyProxy {
                                  _authorizeUpgrade(newImplementation);
                                  _upgradeToAndCallUUPS(newImplementation, new bytes(0), false);
                              }
                              /**
                               * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call
                               * encoded in `data`.
                               *
                               * Calls {_authorizeUpgrade}.
                               *
                               * Emits an {Upgraded} event.
                               */
                              function upgradeToAndCall(address newImplementation, bytes memory data) external payable virtual onlyProxy {
                                  _authorizeUpgrade(newImplementation);
                                  _upgradeToAndCallUUPS(newImplementation, data, true);
                              }
                              /**
                               * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by
                               * {upgradeTo} and {upgradeToAndCall}.
                               *
                               * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.
                               *
                               * ```solidity
                               * function _authorizeUpgrade(address) internal override onlyOwner {}
                               * ```
                               */
                              function _authorizeUpgrade(address newImplementation) internal virtual;
                              /**
                               * @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
                          pragma solidity 0.8.17;
                          import { Validation } from "./Validation.sol";
                          import "./lib/Constants.sol";
                          import {
                              Order,
                              Exchange,
                              FungibleTransfers,
                              StateUpdate,
                              AtomicExecution,
                              AssetType,
                              Fees,
                              FeeRate,
                              Listing,
                              Taker,
                              Transfer,
                              OrderType
                          } from "./lib/Structs.sol";
                          import { IDelegate } from "./interfaces/IDelegate.sol";
                          import { IExecutor } from "./interfaces/IExecutor.sol";
                          abstract contract Executor is IExecutor, Validation {
                              address private immutable _DELEGATE;
                              address private immutable _POOL;
                              constructor(address delegate, address pool, address proxy) Validation(proxy) {
                                  _DELEGATE = delegate;
                                  _POOL = pool;
                              }
                              receive() external payable {
                                  if (msg.sender != _POOL) {
                                      revert Unauthorized();
                                  }
                              }
                              /**
                               * @notice Insert a validated ask listing into the batch if there's sufficient ETH to fulfill
                               * @param executionBatch Execution batch
                               * @param fungibleTransfers Fungible transfers
                               * @param order Order of the listing to insert
                               * @param exchange Exchange containing the listing to insert
                               * @param fees Protocol and taker fees
                               * @param remainingETH Available ETH remaining
                               * @return Available ETH remaining after insertion; if the listing was inserted in the batch
                               */
                              function _insertExecutionAsk(
                                  bytes memory executionBatch,
                                  FungibleTransfers memory fungibleTransfers,
                                  Order memory order,
                                  Exchange memory exchange,
                                  Fees memory fees,
                                  uint256 remainingETH
                              ) internal pure returns (uint256, bool) {
                                  uint256 takerAmount = exchange.taker.amount;
                                  (
                                      uint256 totalPrice,
                                      uint256 protocolFeeAmount,
                                      uint256 makerFeeAmount,
                                      uint256 takerFeeAmount
                                  ) = _computeFees(exchange.listing.price, takerAmount, order.makerFee, fees);
                                  /* Only insert the executions if there are sufficient funds to execute. */
                                  if (remainingETH >= totalPrice + takerFeeAmount) {
                                      unchecked {
                                          remainingETH = remainingETH - totalPrice - takerFeeAmount;
                                      }
                                      _setAddresses(fungibleTransfers, order);
                                      uint256 index = _insertNonfungibleTransfer(
                                          executionBatch,
                                          order,
                                          exchange.listing.tokenId,
                                          takerAmount
                                      );
                                      _insertFungibleTransfers(
                                          fungibleTransfers,
                                          takerAmount,
                                          exchange.listing,
                                          bytes32(order.salt),
                                          index,
                                          totalPrice,
                                          protocolFeeAmount,
                                          makerFeeAmount,
                                          takerFeeAmount,
                                          true
                                      );
                                      return (remainingETH, true);
                                  } else {
                                      return (remainingETH, false);
                                  }
                              }
                              /**
                               * @notice Insert a validated bid listing into the batch
                               * @param executionBatch Execution batch
                               * @param fungibleTransfers Fungible transfers
                               * @param order Order of the listing to insert
                               * @param exchange Exchange containing listing to insert
                               * @param fees Protocol and taker fees
                               */
                              function _insertExecutionBid(
                                  bytes memory executionBatch,
                                  FungibleTransfers memory fungibleTransfers,
                                  Order memory order,
                                  Exchange memory exchange,
                                  Fees memory fees
                              ) internal pure {
                                  uint256 takerAmount = exchange.taker.amount;
                                  (
                                      uint256 totalPrice,
                                      uint256 protocolFeeAmount,
                                      uint256 makerFeeAmount,
                                      uint256 takerFeeAmount
                                  ) = _computeFees(exchange.listing.price, takerAmount, order.makerFee, fees);
                                  _setAddresses(fungibleTransfers, order);
                                  uint256 index = _insertNonfungibleTransfer(
                                      executionBatch,
                                      order,
                                      exchange.taker.tokenId,
                                      takerAmount
                                  );
                                  _insertFungibleTransfers(
                                      fungibleTransfers,
                                      takerAmount,
                                      exchange.listing,
                                      bytes32(order.salt),
                                      index,
                                      totalPrice,
                                      protocolFeeAmount,
                                      makerFeeAmount,
                                      takerFeeAmount,
                                      false
                                  );
                              }
                              /**
                               * @notice Insert the nonfungible transfer into the batch
                               * @param executionBatch Execution batch
                               * @param order Order
                               * @param tokenId Token id
                               * @param amount Number of token units
                               * @return transferIndex Index of the transfer
                               */
                              function _insertNonfungibleTransfer(
                                  bytes memory executionBatch,
                                  Order memory order,
                                  uint256 tokenId,
                                  uint256 amount
                              ) internal pure returns (uint256 transferIndex) {
                                  assembly {
                                      let calldataPointer := add(executionBatch, ExecutionBatch_calldata_offset)
                                      transferIndex := mload(add(calldataPointer, ExecutionBatch_length_offset))
                                      let transfersOffset := mload(add(calldataPointer, ExecutionBatch_transfers_pointer_offset))
                                      let transferPointer := add(
                                          add(calldataPointer, add(transfersOffset, One_word)),
                                          mul(transferIndex, Transfer_size)
                                      )
                                      mstore(
                                          add(transferPointer, Transfer_trader_offset),
                                          mload(add(order, Order_trader_offset))
                                      ) // set the trader
                                      mstore(add(transferPointer, Transfer_id_offset), tokenId) // set the token id
                                      mstore(
                                          add(transferPointer, Transfer_collection_offset),
                                          mload(add(order, Order_collection_offset))
                                      ) // set the collection
                                      mstore(
                                          add(transferPointer, Transfer_assetType_offset),
                                          mload(add(order, Order_assetType_offset))
                                      ) // set the asset type
                                      mstore(add(calldataPointer, ExecutionBatch_length_offset), add(transferIndex, 1)) // increment the batch length
                                      if eq(mload(add(order, Order_assetType_offset)), AssetType_ERC1155) {
                                          mstore(add(transferPointer, Transfer_amount_offset), amount) // set the amount (don't need to set for ERC721's)
                                      }
                                  }
                              }
                              /**
                               * @notice Insert the fungible transfers that need to be executed atomically
                               * @param fungibleTransfers Fungible transfers struct
                               * @param takerAmount Amount of the listing being taken
                               * @param listing Listing to execute
                               * @param orderHash Order hash
                               * @param index Execution index
                               * @param totalPrice Total price of the purchased tokens
                               * @param protocolFeeAmount Computed protocol fee
                               * @param makerFeeAmount Computed maker fee
                               * @param takerFeeAmount Computed taker fee
                               * @param makerIsSeller Is the order maker the seller
                               */
                              function _insertFungibleTransfers(
                                  FungibleTransfers memory fungibleTransfers,
                                  uint256 takerAmount,
                                  Listing memory listing,
                                  bytes32 orderHash,
                                  uint256 index,
                                  uint256 totalPrice,
                                  uint256 protocolFeeAmount,
                                  uint256 makerFeeAmount,
                                  uint256 takerFeeAmount,
                                  bool makerIsSeller
                              ) internal pure {
                                  uint256 makerId = fungibleTransfers.makerId;
                                  fungibleTransfers.executions[index].makerId = makerId;
                                  fungibleTransfers.executions[index].makerFeeRecipientId = fungibleTransfers.feeRecipientId;
                                  fungibleTransfers.executions[index].stateUpdate = StateUpdate({
                                      trader: fungibleTransfers.makers[makerId],
                                      hash: orderHash,
                                      index: listing.index,
                                      value: takerAmount,
                                      maxAmount: listing.amount
                                  });
                                  if (makerIsSeller) {
                                      unchecked {
                                          fungibleTransfers.executions[index].sellerAmount =
                                              totalPrice -
                                              protocolFeeAmount -
                                              makerFeeAmount;
                                      }
                                  } else {
                                      unchecked {
                                          fungibleTransfers.executions[index].sellerAmount =
                                              totalPrice -
                                              protocolFeeAmount -
                                              takerFeeAmount;
                                      }
                                  }
                                  fungibleTransfers.executions[index].makerFeeAmount = makerFeeAmount;
                                  fungibleTransfers.executions[index].takerFeeAmount = takerFeeAmount;
                                  fungibleTransfers.executions[index].protocolFeeAmount = protocolFeeAmount;
                              }
                              /**
                               * @notice Set the addresses of the maker fee recipient and order maker if different than currently being batched
                               * @param fungibleTransfers Fungible transfers struct
                               * @param order Parent order of listing being added to the batch
                               */
                              function _setAddresses(
                                  FungibleTransfers memory fungibleTransfers,
                                  Order memory order
                              ) internal pure {
                                  address feeRecipient = order.makerFee.recipient;
                                  uint256 feeRecipientId = fungibleTransfers.feeRecipientId;
                                  address currentFeeRecipient = fungibleTransfers.feeRecipients[feeRecipientId];
                                  if (feeRecipient != currentFeeRecipient) {
                                      if (currentFeeRecipient == address(0)) {
                                          fungibleTransfers.feeRecipients[feeRecipientId] = feeRecipient;
                                      } else {
                                          unchecked {
                                              fungibleTransfers.feeRecipients[++feeRecipientId] = feeRecipient;
                                          }
                                          fungibleTransfers.feeRecipientId = feeRecipientId;
                                      }
                                  }
                                  address trader = order.trader;
                                  uint256 makerId = fungibleTransfers.makerId;
                                  address currentTrader = fungibleTransfers.makers[makerId];
                                  if (trader != currentTrader) {
                                      if (currentTrader == address(0)) {
                                          fungibleTransfers.makers[makerId] = trader;
                                      } else {
                                          unchecked {
                                              fungibleTransfers.makers[++makerId] = trader;
                                          }
                                          fungibleTransfers.makerId = makerId;
                                      }
                                  }
                              }
                              /**
                               * @notice Compute all necessary fees to be taken
                               * @param pricePerToken Price per token unit
                               * @param takerAmount Number of token units taken (should only be greater than 1 for ERC1155)
                               * @param fees Protocol and taker fee set by the transaction
                               */
                              function _computeFees(
                                  uint256 pricePerToken,
                                  uint256 takerAmount,
                                  FeeRate memory makerFee,
                                  Fees memory fees
                              )
                                  internal
                                  pure
                                  returns (
                                      uint256 totalPrice,
                                      uint256 protocolFeeAmount,
                                      uint256 makerFeeAmount,
                                      uint256 takerFeeAmount
                                  )
                              {
                                  totalPrice = pricePerToken * takerAmount;
                                  makerFeeAmount = (totalPrice * makerFee.rate) / _BASIS_POINTS;
                                  takerFeeAmount = (totalPrice * fees.takerFee.rate) / _BASIS_POINTS;
                                  protocolFeeAmount = (totalPrice * fees.protocolFee.rate) / _BASIS_POINTS;
                              }
                              /*//////////////////////////////////////////////////////////////
                                                  EXECUTION FUNCTIONS
                              //////////////////////////////////////////////////////////////*/
                              /**
                               * @notice Execute the transfers by first attempting the nonfungible transfers, for the successful transfers sum the fungible transfers by the recipients and execute
                               * @param executionBatch Execution batch struct
                               * @param fungibleTransfers Fungible transfers struct
                               * @param fees Protocol, maker, taker fees (note: makerFee will be inaccurate at this point in execution)
                               * @param orderType Order type
                               */
                              function _executeBatchTransfer(
                                  bytes memory executionBatch,
                                  FungibleTransfers memory fungibleTransfers,
                                  Fees memory fees,
                                  OrderType orderType
                              ) internal {
                                  uint256 batchLength;
                                  assembly {
                                      let calldataPointer := add(executionBatch, ExecutionBatch_calldata_offset)
                                      batchLength := mload(add(calldataPointer, ExecutionBatch_length_offset))
                                  }
                                  if (batchLength > 0) {
                                      bool[] memory successfulTransfers = _executeNonfungibleTransfers(
                                          executionBatch,
                                          batchLength
                                      );
                                      uint256 transfersLength = successfulTransfers.length;
                                      for (uint256 i; i < transfersLength; ) {
                                          if (successfulTransfers[i]) {
                                              AtomicExecution memory execution = fungibleTransfers.executions[i];
                                              FeeRate memory makerFee;
                                              uint256 price;
                                              unchecked {
                                                  if (orderType == OrderType.ASK) {
                                                      fungibleTransfers.makerTransfers[execution.makerId] += execution
                                                          .sellerAmount; // amount that needs to be sent *to* the order maker
                                                      price =
                                                          execution.sellerAmount +
                                                          execution.protocolFeeAmount +
                                                          execution.makerFeeAmount;
                                                  } else {
                                                      fungibleTransfers.makerTransfers[execution.makerId] +=
                                                          execution.protocolFeeAmount +
                                                          execution.makerFeeAmount +
                                                          execution.takerFeeAmount +
                                                          execution.sellerAmount; // amount that needs to be taken *from* the order maker
                                                      price =
                                                          execution.sellerAmount +
                                                          execution.protocolFeeAmount +
                                                          execution.takerFeeAmount;
                                                  }
                                                  fungibleTransfers.totalSellerTransfer += execution.sellerAmount; // only for bids
                                                  fungibleTransfers.totalProtocolFee += execution.protocolFeeAmount;
                                                  fungibleTransfers.totalTakerFee += execution.takerFeeAmount;
                                                  fungibleTransfers.feeTransfers[execution.makerFeeRecipientId] += execution
                                                      .makerFeeAmount;
                                                  makerFee = FeeRate(
                                                      fungibleTransfers.feeRecipients[execution.makerFeeRecipientId],
                                                      uint16((execution.makerFeeAmount * _BASIS_POINTS) / price)
                                                  );
                                              }
                                              /* Commit state updates. */
                                              StateUpdate memory stateUpdate = fungibleTransfers.executions[i].stateUpdate;
                                              {
                                                  address trader = stateUpdate.trader;
                                                  bytes32 hash = stateUpdate.hash;
                                                  uint256 index = stateUpdate.index;
                                                  uint256 _amountTaken = amountTaken[trader][hash][index];
                                                  uint256 newAmountTaken = _amountTaken + stateUpdate.value;
                                                  /* Overfulfilled Listings should be caught prior to inserting into the batch, but this check prevents any misuse. */
                                                  if (newAmountTaken <= stateUpdate.maxAmount) {
                                                      amountTaken[trader][hash][index] = newAmountTaken;
                                                  } else {
                                                      revert OrderFulfilled();
                                                  }
                                              }
                                              _emitExecutionEventFromBatch(
                                                  executionBatch,
                                                  price,
                                                  makerFee,
                                                  fees,
                                                  stateUpdate,
                                                  orderType,
                                                  i
                                              );
                                          }
                                          unchecked {
                                              ++i;
                                          }
                                      }
                                      if (orderType == OrderType.ASK) {
                                          /* Transfer the payments to the sellers. */
                                          uint256 makersLength = fungibleTransfers.makerId + 1;
                                          for (uint256 i; i < makersLength; ) {
                                              _transferETH(fungibleTransfers.makers[i], fungibleTransfers.makerTransfers[i]);
                                              unchecked {
                                                  ++i;
                                              }
                                          }
                                          /* Transfer the fees to the fee recipients. */
                                          uint256 feesLength = fungibleTransfers.feeRecipientId + 1;
                                          for (uint256 i; i < feesLength; ) {
                                              _transferETH(
                                                  fungibleTransfers.feeRecipients[i],
                                                  fungibleTransfers.feeTransfers[i]
                                              );
                                              unchecked {
                                                  ++i;
                                              }
                                          }
                                          /* Transfer the protocol fees. */
                                          _transferETH(fees.protocolFee.recipient, fungibleTransfers.totalProtocolFee);
                                          /* Transfer the taker fees. */
                                          _transferETH(fees.takerFee.recipient, fungibleTransfers.totalTakerFee);
                                      } else {
                                          /* Take the pool funds from the buyers. */
                                          uint256 makersLength = fungibleTransfers.makerId + 1;
                                          for (uint256 i; i < makersLength; ) {
                                              _transferPool(
                                                  fungibleTransfers.makers[i],
                                                  address(this),
                                                  fungibleTransfers.makerTransfers[i]
                                              );
                                              unchecked {
                                                  ++i;
                                              }
                                          }
                                          /* Transfer the payment to the seller. */
                                          _transferPool(address(this), msg.sender, fungibleTransfers.totalSellerTransfer);
                                          /* Transfer the fees to the fee recipients. */
                                          uint256 feesLength = fungibleTransfers.feeRecipientId + 1;
                                          for (uint256 i; i < feesLength; ) {
                                              _transferPool(
                                                  address(this),
                                                  fungibleTransfers.feeRecipients[i],
                                                  fungibleTransfers.feeTransfers[i]
                                              );
                                              unchecked {
                                                  ++i;
                                              }
                                          }
                                          /* Transfer the protocol fees. */
                                          _transferPool(
                                              address(this),
                                              fees.protocolFee.recipient,
                                              fungibleTransfers.totalProtocolFee
                                          );
                                          /* Transfer the taker fees. */
                                          _transferPool(
                                              address(this),
                                              fees.takerFee.recipient,
                                              fungibleTransfers.totalTakerFee
                                          );
                                      }
                                  }
                              }
                              /**
                               * @notice Attempt to execute a series of nonfungible transfers through the delegate; reverts will be skipped
                               * @param executionBatch Execution batch struct
                               * @param batchIndex Current available transfer slot in the batch
                               * @return Array indicating which transfers were successful
                               */
                              function _executeNonfungibleTransfers(
                                  bytes memory executionBatch,
                                  uint256 batchIndex
                              ) internal returns (bool[] memory) {
                                  address delegate = _DELEGATE;
                                  /* Initialize the memory space for the successful transfers array returned from the Delegate call. */
                                  uint256 successfulTransfersPointer;
                                  assembly {
                                      successfulTransfersPointer := mload(Memory_pointer)
                                      /* Need to shift the free memory pointer ahead one word to account for the array pointer returned from the call. */
                                      mstore(Memory_pointer, add(successfulTransfersPointer, One_word))
                                  }
                                  bool[] memory successfulTransfers = new bool[](batchIndex);
                                  assembly {
                                      let size := mload(executionBatch)
                                      let selectorPointer := add(executionBatch, ExecutionBatch_selector_offset)
                                      mstore(selectorPointer, shr(Bytes4_shift, Delegate_transfer_selector))
                                      let success := call(
                                          gas(),
                                          delegate,
                                          0,
                                          add(selectorPointer, Delegate_transfer_calldata_offset),
                                          sub(size, Delegate_transfer_calldata_offset),
                                          successfulTransfersPointer,
                                          add(0x40, mul(batchIndex, One_word))
                                      )
                                  }
                                  return successfulTransfers;
                              }
                              /*//////////////////////////////////////////////////////////////
                                                  TRANSFER FUNCTIONS
                              //////////////////////////////////////////////////////////////*/
                              /**
                               * @notice Transfer ETH
                               * @param to Recipient address
                               * @param amount Amount of ETH to send
                               */
                              function _transferETH(address to, uint256 amount) internal {
                                  if (amount > 0) {
                                      bool success;
                                      assembly {
                                          success := call(gas(), to, amount, 0, 0, 0, 0)
                                      }
                                      if (!success) {
                                          revert ETHTransferFailed();
                                      }
                                  }
                              }
                              /**
                               * @notice Transfer pool funds on behalf of a user
                               * @param from Sender address
                               * @param to Recipient address
                               * @param amount Amount to send
                               */
                              function _transferPool(address from, address to, uint256 amount) internal {
                                  if (amount > 0) {
                                      bool success;
                                      address pool = _POOL;
                                      assembly {
                                          let x := mload(Memory_pointer)
                                          mstore(x, ERC20_transferFrom_selector)
                                          mstore(add(x, ERC20_transferFrom_from_offset), from)
                                          mstore(add(x, ERC20_transferFrom_to_offset), to)
                                          mstore(add(x, ERC20_transferFrom_amount_offset), amount)
                                          success := call(gas(), pool, 0, x, ERC20_transferFrom_size, 0, 0)
                                      }
                                      if (!success) {
                                          revert PoolTransferFailed();
                                      }
                                  }
                              }
                              /**
                               * @notice Deposit ETH to user's pool funds
                               * @param to Recipient address
                               * @param amount Amount of ETH to deposit
                               */
                              function _depositPool(address to, uint256 amount) internal {
                                  bool success;
                                  address pool = _POOL;
                                  assembly {
                                      let x := mload(Memory_pointer)
                                      mstore(x, Pool_deposit_selector)
                                      mstore(add(x, Pool_deposit_user_offset), to)
                                      success := call(gas(), pool, amount, x, Pool_deposit_size, 0, 0)
                                  }
                                  if (!success) {
                                      revert PoolDepositFailed();
                                  }
                              }
                              /**
                               * @notice Withdraw ETH from user's pool funds
                               * @param from Address to withdraw from
                               * @param amount Amount of ETH to withdraw
                               */
                              function _withdrawFromPool(address from, uint256 amount) internal {
                                  bool success;
                                  address pool = _POOL;
                                  assembly {
                                      let x := mload(Memory_pointer)
                                      mstore(x, Pool_withdrawFrom_selector)
                                      mstore(add(x, Pool_withdrawFrom_from_offset), from)
                                      mstore(add(x, Pool_withdrawFrom_to_offset), address())
                                      mstore(add(x, Pool_withdrawFrom_amount_offset), amount)
                                      success := call(gas(), pool, 0, x, Pool_withdrawFrom_size, 0, 0)
                                  }
                                  if (!success) {
                                      revert PoolWithdrawFromFailed();
                                  }
                              }
                              /*//////////////////////////////////////////////////////////////
                                                    EVENT EMITTERS
                              //////////////////////////////////////////////////////////////*/
                              /**
                               * @notice Emit Execution event from a single execution
                               * @param executionBatch Execution batch struct
                               * @param price Price of the token purchased
                               * @param fees Protocol, maker, and taker fees taken
                               * @param stateUpdate Fulfillment to be recorded with a successful execution
                               * @param orderType Order type
                               * @param transferIndex Index of the transfer corresponding to the execution
                               */
                              function _emitExecutionEventFromBatch(
                                  bytes memory executionBatch,
                                  uint256 price,
                                  FeeRate memory makerFee,
                                  Fees memory fees,
                                  StateUpdate memory stateUpdate,
                                  OrderType orderType,
                                  uint256 transferIndex
                              ) internal {
                                  Transfer memory transfer;
                                  assembly {
                                      let calldataPointer := add(executionBatch, ExecutionBatch_calldata_offset)
                                      let transfersOffset := mload(add(calldataPointer, ExecutionBatch_transfers_pointer_offset))
                                      transfer := add(
                                          add(calldataPointer, add(transfersOffset, One_word)),
                                          mul(transferIndex, Transfer_size)
                                      )
                                  }
                                  _emitOptimalExecutionEvent(
                                      transfer,
                                      stateUpdate.hash,
                                      stateUpdate.index,
                                      price,
                                      makerFee,
                                      fees,
                                      orderType
                                  );
                              }
                              /**
                               * @notice Emit the Execution event that minimizes the number of bytes in the log
                               * @param transfer The nft transfer
                               * @param orderHash Order hash
                               * @param listingIndex Index of the listing being fulfilled within the order
                               * @param price Price of the token purchased
                               * @param makerFee Maker fees taken
                               * @param fees Protocol, and taker fees taken
                               * @param orderType Order type
                               */
                              function _emitOptimalExecutionEvent(
                                  Transfer memory transfer,
                                  bytes32 orderHash,
                                  uint256 listingIndex,
                                  uint256 price,
                                  FeeRate memory makerFee,
                                  Fees memory fees,
                                  OrderType orderType
                              ) internal {
                                  if (
                                      // see _insertNonfungibleTransfer; ERC721 transfers don't set the transfer amount,
                                      // so we can assume the transfer amount and not check it
                                      transfer.assetType == AssetType.ERC721 &&
                                      fees.protocolFee.rate == 0 &&
                                      transfer.id < 1 << (11 * 8) &&
                                      listingIndex < 1 << (1 * 8) &&
                                      price < 1 << (11 * 8)
                                  ) {
                                      if (makerFee.rate == 0 && fees.takerFee.rate == 0) {
                                          emit Execution721Packed(
                                              orderHash,
                                              packTokenIdListingIndexTrader(transfer.id, listingIndex, transfer.trader),
                                              packTypePriceCollection(orderType, price, transfer.collection)
                                          );
                                          return;
                                      } else if (makerFee.rate == 0) {
                                          emit Execution721TakerFeePacked(
                                              orderHash,
                                              packTokenIdListingIndexTrader(transfer.id, listingIndex, transfer.trader),
                                              packTypePriceCollection(orderType, price, transfer.collection),
                                              packFee(fees.takerFee)
                                          );
                                          return;
                                      } else if (fees.takerFee.rate == 0) {
                                          emit Execution721MakerFeePacked(
                                              orderHash,
                                              packTokenIdListingIndexTrader(transfer.id, listingIndex, transfer.trader),
                                              packTypePriceCollection(orderType, price, transfer.collection),
                                              packFee(makerFee)
                                          );
                                          return;
                                      }
                                  }
                                  emit Execution({
                                      transfer: transfer,
                                      orderHash: orderHash,
                                      listingIndex: listingIndex,
                                      price: price,
                                      makerFee: makerFee,
                                      fees: fees,
                                      orderType: orderType
                                  });
                              }
                              /**
                               * @notice Emit Execution event from a single execution
                               * @param executionBatch Execution batch struct
                               * @param order Order being fulfilled
                               * @param listingIndex Index of the listing being fulfilled within the order
                               * @param price Price of the token purchased
                               * @param fees Protocol, and taker fees taken
                               * @param orderType Order type
                               */
                              function _emitExecutionEvent(
                                  bytes memory executionBatch,
                                  Order memory order,
                                  uint256 listingIndex,
                                  uint256 price,
                                  Fees memory fees,
                                  OrderType orderType
                              ) internal {
                                  Transfer memory transfer;
                                  assembly {
                                      let calldataPointer := add(executionBatch, ExecutionBatch_calldata_offset)
                                      let transfersOffset := mload(add(calldataPointer, ExecutionBatch_transfers_pointer_offset))
                                      transfer := add(calldataPointer, add(transfersOffset, One_word))
                                  }
                                  _emitOptimalExecutionEvent(
                                      transfer,
                                      bytes32(order.salt),
                                      listingIndex,
                                      price,
                                      order.makerFee,
                                      fees,
                                      orderType
                                  );
                              }
                              function packTokenIdListingIndexTrader(
                                  uint256 tokenId,
                                  uint256 listingIndex,
                                  address trader
                              ) private pure returns (uint256) {
                                  return (tokenId << (21 * 8)) | (listingIndex << (20 * 8)) | uint160(trader);
                              }
                              function packTypePriceCollection(
                                  OrderType orderType,
                                  uint256 price,
                                  address collection
                              ) private pure returns (uint256) {
                                  return (uint256(orderType) << (31 * 8)) | (price << (20 * 8)) | uint160(collection);
                              }
                              function packFee(FeeRate memory fee) private pure returns (uint256) {
                                  return (uint256(fee.rate) << (20 * 8)) | uint160(fee.recipient);
                              }
                              uint256[50] private __gap;
                          }
                          // SPDX-License-Identifier: MIT
                          pragma solidity 0.8.17;
                          uint256 constant Bytes1_shift = 0xf8;
                          uint256 constant Bytes4_shift = 0xe0;
                          uint256 constant Bytes20_shift = 0x60;
                          uint256 constant One_word = 0x20;
                          uint256 constant Memory_pointer = 0x40;
                          uint256 constant AssetType_ERC721 = 0;
                          uint256 constant AssetType_ERC1155 = 1;
                          uint256 constant OrderType_ASK = 0;
                          uint256 constant OrderType_BID = 1;
                          uint256 constant Pool_withdrawFrom_selector = 0x9555a94200000000000000000000000000000000000000000000000000000000;
                          uint256 constant Pool_withdrawFrom_from_offset = 0x04;
                          uint256 constant Pool_withdrawFrom_to_offset = 0x24;
                          uint256 constant Pool_withdrawFrom_amount_offset = 0x44;
                          uint256 constant Pool_withdrawFrom_size = 0x64;
                          uint256 constant Pool_deposit_selector = 0xf340fa0100000000000000000000000000000000000000000000000000000000;
                          uint256 constant Pool_deposit_user_offset = 0x04;
                          uint256 constant Pool_deposit_size = 0x24;
                          uint256 constant ERC20_transferFrom_selector = 0x23b872dd00000000000000000000000000000000000000000000000000000000;
                          uint256 constant ERC721_safeTransferFrom_selector = 0x42842e0e00000000000000000000000000000000000000000000000000000000;
                          uint256 constant ERC1155_safeTransferFrom_selector = 0xf242432a00000000000000000000000000000000000000000000000000000000;
                          uint256 constant ERC20_transferFrom_size = 0x64;
                          uint256 constant ERC721_safeTransferFrom_size = 0x64;
                          uint256 constant ERC1155_safeTransferFrom_size = 0xc4;
                          uint256 constant OracleSignatures_size = 0x59;
                          uint256 constant OracleSignatures_s_offset = 0x20;
                          uint256 constant OracleSignatures_v_offset = 0x40;
                          uint256 constant OracleSignatures_blockNumber_offset = 0x41;
                          uint256 constant OracleSignatures_oracle_offset = 0x45;
                          uint256 constant Signatures_size = 0x41;
                          uint256 constant Signatures_s_offset = 0x20;
                          uint256 constant Signatures_v_offset = 0x40;
                          uint256 constant ERC20_transferFrom_from_offset = 0x4;
                          uint256 constant ERC20_transferFrom_to_offset = 0x24;
                          uint256 constant ERC20_transferFrom_amount_offset = 0x44;
                          uint256 constant ERC721_safeTransferFrom_from_offset = 0x4;
                          uint256 constant ERC721_safeTransferFrom_to_offset = 0x24;
                          uint256 constant ERC721_safeTransferFrom_id_offset = 0x44;
                          uint256 constant ERC1155_safeTransferFrom_from_offset = 0x4;
                          uint256 constant ERC1155_safeTransferFrom_to_offset = 0x24;
                          uint256 constant ERC1155_safeTransferFrom_id_offset = 0x44;
                          uint256 constant ERC1155_safeTransferFrom_amount_offset = 0x64;
                          uint256 constant ERC1155_safeTransferFrom_data_pointer_offset = 0x84;
                          uint256 constant ERC1155_safeTransferFrom_data_offset = 0xa4;
                          uint256 constant Delegate_transfer_selector = 0xa1ccb98e00000000000000000000000000000000000000000000000000000000;
                          uint256 constant Delegate_transfer_calldata_offset = 0x1c;
                          uint256 constant Order_size = 0x100;
                          uint256 constant Order_trader_offset = 0x00;
                          uint256 constant Order_collection_offset = 0x20;
                          uint256 constant Order_listingsRoot_offset = 0x40;
                          uint256 constant Order_numberOfListings_offset = 0x60;
                          uint256 constant Order_expirationTime_offset = 0x80;
                          uint256 constant Order_assetType_offset = 0xa0;
                          uint256 constant Order_makerFee_offset = 0xc0;
                          uint256 constant Order_salt_offset = 0xe0;
                          uint256 constant Exchange_size = 0x80;
                          uint256 constant Exchange_askIndex_offset = 0x00;
                          uint256 constant Exchange_proof_offset = 0x20;
                          uint256 constant Exchange_maker_offset = 0x40;
                          uint256 constant Exchange_taker_offset = 0x60;
                          uint256 constant BidExchange_size = 0x80;
                          uint256 constant BidExchange_askIndex_offset = 0x00;
                          uint256 constant BidExchange_proof_offset = 0x20;
                          uint256 constant BidExchange_maker_offset = 0x40;
                          uint256 constant BidExchange_taker_offset = 0x60;
                          uint256 constant Listing_size = 0x80;
                          uint256 constant Listing_index_offset = 0x00;
                          uint256 constant Listing_tokenId_offset = 0x20;
                          uint256 constant Listing_amount_offset = 0x40;
                          uint256 constant Listing_price_offset = 0x60;
                          uint256 constant Taker_size = 0x40;
                          uint256 constant Taker_tokenId_offset = 0x00;
                          uint256 constant Taker_amount_offset = 0x20;
                          uint256 constant StateUpdate_size = 0x80;
                          uint256 constant StateUpdate_salt_offset = 0x20;
                          uint256 constant StateUpdate_leaf_offset = 0x40;
                          uint256 constant StateUpdate_value_offset = 0x60;
                          uint256 constant Transfer_size = 0xa0;
                          uint256 constant Transfer_trader_offset = 0x00;
                          uint256 constant Transfer_id_offset = 0x20;
                          uint256 constant Transfer_amount_offset = 0x40;
                          uint256 constant Transfer_collection_offset = 0x60;
                          uint256 constant Transfer_assetType_offset = 0x80;
                          uint256 constant ExecutionBatch_selector_offset = 0x20;
                          uint256 constant ExecutionBatch_calldata_offset = 0x40;
                          uint256 constant ExecutionBatch_base_size = 0xa0; // size of the executionBatch without the flattened dynamic elements
                          uint256 constant ExecutionBatch_taker_offset = 0x00;
                          uint256 constant ExecutionBatch_orderType_offset = 0x20;
                          uint256 constant ExecutionBatch_transfers_pointer_offset = 0x40;
                          uint256 constant ExecutionBatch_length_offset = 0x60;
                          uint256 constant ExecutionBatch_transfers_offset = 0x80;
                          // SPDX-License-Identifier: MIT
                          pragma solidity ^0.8.17;
                          struct TakeAsk {
                              Order[] orders;
                              Exchange[] exchanges;
                              FeeRate takerFee;
                              bytes signatures;
                              address tokenRecipient;
                          }
                          struct TakeAskSingle {
                              Order order;
                              Exchange exchange;
                              FeeRate takerFee;
                              bytes signature;
                              address tokenRecipient;
                          }
                          struct TakeBid {
                              Order[] orders;
                              Exchange[] exchanges;
                              FeeRate takerFee;
                              bytes signatures;
                          }
                          struct TakeBidSingle {
                              Order order;
                              Exchange exchange;
                              FeeRate takerFee;
                              bytes signature;
                          }
                          enum AssetType {
                              ERC721,
                              ERC1155
                          }
                          enum OrderType {
                              ASK,
                              BID
                          }
                          struct Exchange { // Size: 0x80
                              uint256 index; // 0x00
                              bytes32[] proof; // 0x20
                              Listing listing; // 0x40
                              Taker taker; // 0x60
                          }
                          struct Listing { // Size: 0x80
                              uint256 index; // 0x00
                              uint256 tokenId; // 0x20
                              uint256 amount; // 0x40
                              uint256 price; // 0x60
                          }
                          struct Taker { // Size: 0x40
                              uint256 tokenId; // 0x00
                              uint256 amount; // 0x20
                          }
                          struct Order { // Size: 0x100
                              address trader; // 0x00
                              address collection; // 0x20
                              bytes32 listingsRoot; // 0x40
                              uint256 numberOfListings; // 0x60
                              uint256 expirationTime; // 0x80
                              AssetType assetType; // 0xa0
                              FeeRate makerFee; // 0xc0
                              uint256 salt; // 0xe0
                          }
                          /*
                          Reference only; struct is composed manually using calldata formatting in execution
                          struct ExecutionBatch { // Size: 0x80
                              address taker; // 0x00
                              OrderType orderType; // 0x20
                              Transfer[] transfers; // 0x40
                              uint256 length; // 0x60
                          }
                          */
                          struct Transfer { // Size: 0xa0
                              address trader; // 0x00
                              uint256 id; // 0x20
                              uint256 amount; // 0x40
                              address collection; // 0x60
                              AssetType assetType; // 0x80
                          }
                          struct FungibleTransfers {
                              uint256 totalProtocolFee;
                              uint256 totalSellerTransfer;
                              uint256 totalTakerFee;
                              uint256 feeRecipientId;
                              uint256 makerId;
                              address[] feeRecipients;
                              address[] makers;
                              uint256[] makerTransfers;
                              uint256[] feeTransfers;
                              AtomicExecution[] executions;
                          }
                          struct AtomicExecution { // Size: 0xe0
                              uint256 makerId; // 0x00
                              uint256 sellerAmount; // 0x20
                              uint256 makerFeeRecipientId; // 0x40
                              uint256 makerFeeAmount; // 0x60
                              uint256 takerFeeAmount; // 0x80
                              uint256 protocolFeeAmount; // 0xa0
                              StateUpdate stateUpdate; // 0xc0
                          }
                          struct StateUpdate { // Size: 0xa0
                              address trader; // 0x00
                              bytes32 hash; // 0x20
                              uint256 index; // 0x40
                              uint256 value; // 0x60
                              uint256 maxAmount; // 0x80
                          }
                          struct Fees { // Size: 0x40
                              FeeRate protocolFee; // 0x00
                              FeeRate takerFee; // 0x20
                          }
                          struct FeeRate { // Size: 0x40
                              address recipient; // 0x00
                              uint16 rate; // 0x20
                          }
                          struct Cancel {
                              bytes32 hash;
                              uint256 index;
                              uint256 amount;
                          }
                          // SPDX-License-Identifier: MIT
                          pragma solidity 0.8.17;
                          import {
                              TakeAsk,
                              TakeBid,
                              TakeAskSingle,
                              TakeBidSingle,
                              Order,
                              Exchange,
                              Fees,
                              FeeRate,
                              AssetType,
                              OrderType,
                              Transfer,
                              FungibleTransfers,
                              StateUpdate,
                              Cancel,
                              Listing
                          } from "../lib/Structs.sol";
                          interface IBlurExchangeV2 {
                              error InsufficientFunds();
                              error TokenTransferFailed();
                              error InvalidOrder();
                              error ProtocolFeeTooHigh();
                              event NewProtocolFee(address indexed recipient, uint16 indexed rate);
                              event NewGovernor(address indexed governor);
                              event NewBlockRange(uint256 blockRange);
                              event CancelTrade(address indexed user, bytes32 hash, uint256 index, uint256 amount);
                              event NonceIncremented(address indexed user, uint256 newNonce);
                              event SetOracle(address indexed user, bool approved);
                              function initialize() external;
                              function setProtocolFee(address recipient, uint16 rate) external;
                              function setGovernor(address _governor) external;
                              function setOracle(address oracle, bool approved) external;
                              function setBlockRange(uint256 _blockRange) external;
                              function cancelTrades(Cancel[] memory cancels) external;
                              function incrementNonce() external;
                              /*//////////////////////////////////////////////////////////////
                                                    EXECUTION WRAPPERS
                              //////////////////////////////////////////////////////////////*/
                              function takeAsk(TakeAsk memory inputs, bytes calldata oracleSignature) external payable;
                              function takeBid(TakeBid memory inputs, bytes calldata oracleSignature) external;
                              function takeAskSingle(TakeAskSingle memory inputs, bytes calldata oracleSignature) external payable;
                              function takeBidSingle(TakeBidSingle memory inputs, bytes calldata oracleSignature) external;
                              /*//////////////////////////////////////////////////////////////
                                                  EXECUTION POOL WRAPPERS
                              //////////////////////////////////////////////////////////////*/
                              function takeAskSinglePool(
                                  TakeAskSingle memory inputs,
                                  bytes calldata oracleSignature,
                                  uint256 amountToWithdraw
                              ) external payable;
                              function takeAskPool(
                                  TakeAsk memory inputs,
                                  bytes calldata oracleSignature,
                                  uint256 amountToWithdraw
                              ) external payable;
                          }
                          // SPDX-License-Identifier: AGPL-3.0-only
                          pragma solidity 0.8.17;
                          /// @notice Upgradeable gas optimized reentrancy protection for smart contracts.
                          /// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/ReentrancyGuard.sol)
                          abstract contract ReentrancyGuardUpgradeable {
                              uint256 private locked;
                              function __Reentrancy_init() internal {
                                  locked = 1;
                              }
                              modifier nonReentrant() virtual {
                                  require(locked == 1, "REENTRANCY");
                                  locked = 2;
                                  _;
                                  locked = 1;
                              }
                              uint256[49] private __gap;
                          }
                          // 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.1) (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 Returns the highest version that has been initialized. See {reinitializer}.
                               */
                              function _getInitializedVersion() internal view returns (uint8) {
                                  return _initialized;
                              }
                              /**
                               * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
                               */
                              function _isInitializing() internal view returns (bool) {
                                  return _initializing;
                              }
                          }
                          // 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) (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 (last updated v4.5.0) (interfaces/draft-IERC1822.sol)
                          pragma solidity ^0.8.0;
                          /**
                           * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
                           * proxy whose upgrades are fully controlled by the current implementation.
                           */
                          interface IERC1822ProxiableUpgradeable {
                              /**
                               * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
                               * address.
                               *
                               * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
                               * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
                               * function revert if invoked through a proxy.
                               */
                              function proxiableUUID() external view returns (bytes32);
                          }
                          // SPDX-License-Identifier: MIT
                          // OpenZeppelin Contracts (last updated v4.8.3) (proxy/ERC1967/ERC1967Upgrade.sol)
                          pragma solidity ^0.8.2;
                          import "../beacon/IBeaconUpgradeable.sol";
                          import "../../interfaces/IERC1967Upgradeable.sol";
                          import "../../interfaces/draft-IERC1822Upgradeable.sol";
                          import "../../utils/AddressUpgradeable.sol";
                          import "../../utils/StorageSlotUpgradeable.sol";
                          import "../utils/Initializable.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 ERC1967UpgradeUpgradeable is Initializable, IERC1967Upgradeable {
                              function __ERC1967Upgrade_init() internal onlyInitializing {
                              }
                              function __ERC1967Upgrade_init_unchained() internal onlyInitializing {
                              }
                              // 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 Returns the current implementation address.
                               */
                              function _getImplementation() internal view returns (address) {
                                  return StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value;
                              }
                              /**
                               * @dev Stores a new address in the EIP1967 implementation slot.
                               */
                              function _setImplementation(address newImplementation) private {
                                  require(AddressUpgradeable.isContract(newImplementation), "ERC1967: new implementation is not a contract");
                                  StorageSlotUpgradeable.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 {
                                  _upgradeTo(newImplementation);
                                  if (data.length > 0 || forceCall) {
                                      _functionDelegateCall(newImplementation, data);
                                  }
                              }
                              /**
                               * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
                               *
                               * Emits an {Upgraded} event.
                               */
                              function _upgradeToAndCallUUPS(
                                  address newImplementation,
                                  bytes memory data,
                                  bool forceCall
                              ) internal {
                                  // Upgrades from old implementations will perform a rollback test. This test requires the new
                                  // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
                                  // this special case will break upgrade paths from old UUPS implementation to new ones.
                                  if (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) {
                                      _setImplementation(newImplementation);
                                  } else {
                                      try IERC1822ProxiableUpgradeable(newImplementation).proxiableUUID() returns (bytes32 slot) {
                                          require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
                                      } catch {
                                          revert("ERC1967Upgrade: new implementation is not UUPS");
                                      }
                                      _upgradeToAndCall(newImplementation, data, forceCall);
                                  }
                              }
                              /**
                               * @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 Returns the current admin.
                               */
                              function _getAdmin() internal view returns (address) {
                                  return StorageSlotUpgradeable.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");
                                  StorageSlotUpgradeable.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 Returns the current beacon.
                               */
                              function _getBeacon() internal view returns (address) {
                                  return StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value;
                              }
                              /**
                               * @dev Stores a new beacon in the EIP1967 beacon slot.
                               */
                              function _setBeacon(address newBeacon) private {
                                  require(AddressUpgradeable.isContract(newBeacon), "ERC1967: new beacon is not a contract");
                                  require(
                                      AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()),
                                      "ERC1967: beacon implementation is not a contract"
                                  );
                                  StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value = newBeacon;
                              }
                              /**
                               * @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) {
                                      _functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data);
                                  }
                              }
                              /**
                               * @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) private returns (bytes memory) {
                                  require(AddressUpgradeable.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 AddressUpgradeable.verifyCallResult(success, returndata, "Address: low-level delegate call failed");
                              }
                              /**
                               * @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 v4.4.1 (proxy/beacon/IBeacon.sol)
                          pragma solidity ^0.8.0;
                          /**
                           * @dev This is the interface that {BeaconProxy} expects of its beacon.
                           */
                          interface IBeaconUpgradeable {
                              /**
                               * @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
                          // OpenZeppelin Contracts (last updated v4.8.3) (interfaces/IERC1967.sol)
                          pragma solidity ^0.8.0;
                          /**
                           * @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC.
                           *
                           * _Available since v4.9._
                           */
                          interface IERC1967Upgradeable {
                              /**
                               * @dev Emitted when the implementation is upgraded.
                               */
                              event Upgraded(address indexed implementation);
                              /**
                               * @dev Emitted when the admin account has changed.
                               */
                              event AdminChanged(address previousAdmin, address newAdmin);
                              /**
                               * @dev Emitted when the beacon is changed.
                               */
                              event BeaconUpgraded(address indexed beacon);
                          }
                          // SPDX-License-Identifier: MIT
                          // OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)
                          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 StorageSlotUpgradeable {
                              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) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r.slot := slot
                                  }
                              }
                              /**
                               * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
                               */
                              function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r.slot := slot
                                  }
                              }
                              /**
                               * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
                               */
                              function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r.slot := slot
                                  }
                              }
                              /**
                               * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
                               */
                              function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      r.slot := slot
                                  }
                              }
                          }
                          // SPDX-License-Identifier: MIT
                          pragma solidity 0.8.17;
                          import { MerkleProof } from "lib/openzeppelin-contracts/contracts/utils/cryptography/MerkleProof.sol";
                          import { Signatures } from "./Signatures.sol";
                          import { AssetType, Order, Exchange, Listing, OrderType, FeeRate, Fees, Taker } from "./lib/Structs.sol";
                          import { IValidation } from "./interfaces/IValidation.sol";
                          abstract contract Validation is IValidation, Signatures {
                              uint256 internal constant _BASIS_POINTS = 10_000;
                              uint256 internal constant _MAX_PROTOCOL_FEE_RATE = 250;
                              FeeRate public protocolFee;
                              /* amountTaken[user][orderHash][listingIndex] */
                              mapping(address => mapping(bytes32 => mapping(uint256 => uint256))) public amountTaken;
                              constructor(address proxy) Signatures(proxy) {}
                              /**
                               * @notice Check if an order has expired
                               * @param order Order to check liveness
                               * @return Order is live
                               */
                              function _checkLiveness(Order memory order) private view returns (bool) {
                                  return (order.expirationTime > block.timestamp);
                              }
                              /**
                               * @notice Check that the fees to be taken will not overflow the purchase price
                               * @param makerFee Maker fee amount
                               * @param fees Protocol and taker fee rates
                               * @return Fees are valid
                               */
                              function _checkFee(FeeRate memory makerFee, Fees memory fees) private pure returns (bool) {
                                  return makerFee.rate + fees.takerFee.rate + fees.protocolFee.rate <= _BASIS_POINTS;
                              }
                              /**
                               * @notice Validate a list of orders and prepare arrays for recording pending fulfillments
                               * @param orders List of orders
                               * @param orderType Order type for all orders
                               * @param signatures Bytes array of the order signatures
                               * @param fees Protocol and taker fee rates
                               */
                              function _validateOrders(
                                  Order[] memory orders,
                                  OrderType orderType,
                                  bytes memory signatures,
                                  Fees memory fees
                              ) internal view returns (bool[] memory validOrders, uint256[][] memory pendingAmountTaken) {
                                  uint256 ordersLength = orders.length;
                                  validOrders = new bool[](ordersLength);
                                  pendingAmountTaken = new uint256[][](ordersLength);
                                  for (uint256 i; i < ordersLength; ) {
                                      pendingAmountTaken[i] = new uint256[](orders[i].numberOfListings);
                                      validOrders[i] = _validateOrder(orders[i], orderType, signatures, fees, i);
                                      unchecked {
                                          ++i;
                                      }
                                  }
                              }
                              /**
                               * @notice Validate an order
                               * @param order Order to validate
                               * @param orderType Order type
                               * @param signatures Bytes array of order signatures
                               * @param fees Protocol and taker fee rates
                               * @param signatureIndex Index of the order signature
                               * @return Validity of the order
                               */
                              function _validateOrder(
                                  Order memory order,
                                  OrderType orderType,
                                  bytes memory signatures,
                                  Fees memory fees,
                                  uint256 signatureIndex
                              ) internal view returns (bool) {
                                  bytes32 orderHash = hashOrder(order, orderType);
                                  /* After hashing, the salt is no longer needed so we can store the order hash here. */
                                  order.salt = uint256(orderHash);
                                  return _verifyAuthorization(
                                      order.trader,
                                      orderHash,
                                      signatures,
                                      signatureIndex
                                  ) &&
                                      _checkLiveness(order) &&
                                      _checkFee(order.makerFee, fees);
                              }
                              /**
                               * @notice Validate a listing (only valid if the order has be prevalidated)
                               * @dev Validation can be manipulated by inputting the same order twice in the orders array,
                               * which will effectively bypass the `pendingAmountTaken` check. There is a safety check at the
                               * execution phase that will revert the transaction if this manipulation overdraws an order.
                               * @param order Order of the listing
                               * @param orderType Order type
                               * @param exchange Exchange containing the listing
                               * @param validOrders List indicated which orders were validated
                               * @param pendingAmountTaken Pending fulfillments from the current batch
                               * @return validListing Validity of the listing
                               */
                              function _validateListingFromBatch(
                                  Order memory order,
                                  OrderType orderType,
                                  Exchange memory exchange,
                                  bool[] memory validOrders,
                                  uint256[][] memory pendingAmountTaken
                              ) internal view returns (bool validListing) {
                                  Listing memory listing = exchange.listing;
                                  uint256 listingIndex = listing.index;
                                  uint256 amountTaken = amountTaken[order.trader][bytes32(order.salt)][listingIndex];
                                  uint256 pendingAmountTaken = pendingAmountTaken[exchange.index][listingIndex];
                                  uint256 takerAmount = exchange.taker.amount;
                                  unchecked {
                                      validListing =
                                          validOrders[exchange.index] &&
                                          _validateListing(order, orderType, exchange) &&
                                          pendingAmountTaken + takerAmount <= type(uint256).max - amountTaken &&
                                          amountTaken + pendingAmountTaken + takerAmount <= listing.amount;
                                  }
                              }
                              /**
                               * @notice Validate a listing and its proposed exchange
                               * @param order Order of the listing
                               * @param orderType Order type
                               * @param exchange Exchange containing the listing
                               * @return validListing Validity of the listing and its proposed exchange
                               */
                              function _validateListing(
                                  Order memory order,
                                  OrderType orderType,
                                  Exchange memory exchange
                              ) private pure returns (bool validListing) {
                                  Listing memory listing = exchange.listing;
                                  validListing = MerkleProof.verify(exchange.proof, order.listingsRoot, hashListing(listing));
                                  Taker memory taker = exchange.taker;
                                  if (orderType == OrderType.ASK) {
                                      if (order.assetType == AssetType.ERC721) {
                                          validListing = validListing && taker.amount == 1 && listing.amount == 1;
                                      }
                                      validListing = validListing && listing.tokenId == taker.tokenId;
                                  } else {
                                      if (order.assetType == AssetType.ERC721) {
                                          validListing = validListing && taker.amount == 1;
                                      } else {
                                          validListing = validListing && listing.tokenId == taker.tokenId;
                                      }
                                  }
                              }
                              /**
                               * @notice Validate both the listing and it's parent order (only for single executions)
                               * @param order Order of the listing
                               * @param orderType Order type
                               * @param exchange Exchange containing the listing
                               * @param signature Order signature
                               * @param fees Protocol and taker fee rates
                               * @return Validity of the order and listing
                               */
                              function _validateOrderAndListing(
                                  Order memory order,
                                  OrderType orderType,
                                  Exchange memory exchange,
                                  bytes memory signature,
                                  Fees memory fees
                              ) internal view returns (bool) {
                                  Listing memory listing = exchange.listing;
                                  uint256 listingIndex = listing.index;
                                  return
                                      _validateOrder(order, orderType, signature, fees, 0) &&
                                      _validateListing(order, orderType, exchange) &&
                                      amountTaken[order.trader][bytes32(order.salt)][listingIndex] + exchange.taker.amount <=
                                      listing.amount;
                              }
                              uint256[49] private __gap;
                          }
                          // SPDX-License-Identifier: MIT
                          pragma solidity 0.8.17;
                          import { AssetType, OrderType, Transfer } from "../lib/Structs.sol";
                          interface IDelegate {
                              function transfer(
                                  address caller,
                                  OrderType orderType,
                                  Transfer[] calldata transfers,
                                  uint256 length
                              ) external returns (bool[] memory successful);
                          }
                          // SPDX-License-Identifier: MIT
                          pragma solidity 0.8.17;
                          import {
                              Fees,
                              FeeRate,
                              Transfer,
                              OrderType
                          } from "../lib/Structs.sol";
                          interface IExecutor {
                              error ETHTransferFailed();
                              error PoolTransferFailed();
                              error PoolWithdrawFromFailed();
                              error PoolDepositFailed();
                              error OrderFulfilled();
                              event Execution(
                                  Transfer transfer,
                                  bytes32 orderHash,
                                  uint256 listingIndex,
                                  uint256 price,
                                  FeeRate makerFee,
                                  Fees fees,
                                  OrderType orderType
                              );
                              event Execution721Packed(
                                  bytes32 orderHash,
                                  uint256 tokenIdListingIndexTrader,
                                  uint256 collectionPriceSide
                              );
                              event Execution721TakerFeePacked(
                                  bytes32 orderHash,
                                  uint256 tokenIdListingIndexTrader,
                                  uint256 collectionPriceSide,
                                  uint256 takerFeeRecipientRate
                              );
                              event Execution721MakerFeePacked(
                                  bytes32 orderHash,
                                  uint256 tokenIdListingIndexTrader,
                                  uint256 collectionPriceSide,
                                  uint256 makerFeeRecipientRate
                              );
                          }
                          // SPDX-License-Identifier: MIT
                          // OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/MerkleProof.sol)
                          pragma solidity ^0.8.0;
                          /**
                           * @dev These functions deal with verification of Merkle Tree proofs.
                           *
                           * The tree and the proofs can be generated using our
                           * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
                           * You will find a quickstart guide in the readme.
                           *
                           * WARNING: You should avoid using leaf values that are 64 bytes long prior to
                           * hashing, or use a hash function other than keccak256 for hashing leaves.
                           * This is because the concatenation of a sorted pair of internal nodes in
                           * the merkle tree could be reinterpreted as a leaf value.
                           * OpenZeppelin's JavaScript library generates merkle trees that are safe
                           * against this attack out of the box.
                           */
                          library MerkleProof {
                              /**
                               * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
                               * defined by `root`. For this, a `proof` must be provided, containing
                               * sibling hashes on the branch from the leaf to the root of the tree. Each
                               * pair of leaves and each pair of pre-images are assumed to be sorted.
                               */
                              function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
                                  return processProof(proof, leaf) == root;
                              }
                              /**
                               * @dev Calldata version of {verify}
                               *
                               * _Available since v4.7._
                               */
                              function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
                                  return processProofCalldata(proof, leaf) == root;
                              }
                              /**
                               * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
                               * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
                               * hash matches the root of the tree. When processing the proof, the pairs
                               * of leafs & pre-images are assumed to be sorted.
                               *
                               * _Available since v4.4._
                               */
                              function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
                                  bytes32 computedHash = leaf;
                                  for (uint256 i = 0; i < proof.length; i++) {
                                      computedHash = _hashPair(computedHash, proof[i]);
                                  }
                                  return computedHash;
                              }
                              /**
                               * @dev Calldata version of {processProof}
                               *
                               * _Available since v4.7._
                               */
                              function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
                                  bytes32 computedHash = leaf;
                                  for (uint256 i = 0; i < proof.length; i++) {
                                      computedHash = _hashPair(computedHash, proof[i]);
                                  }
                                  return computedHash;
                              }
                              /**
                               * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a merkle tree defined by
                               * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
                               *
                               * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
                               *
                               * _Available since v4.7._
                               */
                              function multiProofVerify(
                                  bytes32[] memory proof,
                                  bool[] memory proofFlags,
                                  bytes32 root,
                                  bytes32[] memory leaves
                              ) internal pure returns (bool) {
                                  return processMultiProof(proof, proofFlags, leaves) == root;
                              }
                              /**
                               * @dev Calldata version of {multiProofVerify}
                               *
                               * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
                               *
                               * _Available since v4.7._
                               */
                              function multiProofVerifyCalldata(
                                  bytes32[] calldata proof,
                                  bool[] calldata proofFlags,
                                  bytes32 root,
                                  bytes32[] memory leaves
                              ) internal pure returns (bool) {
                                  return processMultiProofCalldata(proof, proofFlags, leaves) == root;
                              }
                              /**
                               * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
                               * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
                               * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
                               * respectively.
                               *
                               * CAUTION: Not all merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
                               * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
                               * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
                               *
                               * _Available since v4.7._
                               */
                              function processMultiProof(
                                  bytes32[] memory proof,
                                  bool[] memory proofFlags,
                                  bytes32[] memory leaves
                              ) internal pure returns (bytes32 merkleRoot) {
                                  // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
                                  // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
                                  // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
                                  // the merkle tree.
                                  uint256 leavesLen = leaves.length;
                                  uint256 totalHashes = proofFlags.length;
                                  // Check proof validity.
                                  require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");
                                  // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
                                  // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
                                  bytes32[] memory hashes = new bytes32[](totalHashes);
                                  uint256 leafPos = 0;
                                  uint256 hashPos = 0;
                                  uint256 proofPos = 0;
                                  // At each step, we compute the next hash using two values:
                                  // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
                                  //   get the next hash.
                                  // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
                                  //   `proof` array.
                                  for (uint256 i = 0; i < totalHashes; i++) {
                                      bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
                                      bytes32 b = proofFlags[i]
                                          ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                                          : proof[proofPos++];
                                      hashes[i] = _hashPair(a, b);
                                  }
                                  if (totalHashes > 0) {
                                      unchecked {
                                          return hashes[totalHashes - 1];
                                      }
                                  } else if (leavesLen > 0) {
                                      return leaves[0];
                                  } else {
                                      return proof[0];
                                  }
                              }
                              /**
                               * @dev Calldata version of {processMultiProof}.
                               *
                               * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
                               *
                               * _Available since v4.7._
                               */
                              function processMultiProofCalldata(
                                  bytes32[] calldata proof,
                                  bool[] calldata proofFlags,
                                  bytes32[] memory leaves
                              ) internal pure returns (bytes32 merkleRoot) {
                                  // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
                                  // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
                                  // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
                                  // the merkle tree.
                                  uint256 leavesLen = leaves.length;
                                  uint256 totalHashes = proofFlags.length;
                                  // Check proof validity.
                                  require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");
                                  // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
                                  // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
                                  bytes32[] memory hashes = new bytes32[](totalHashes);
                                  uint256 leafPos = 0;
                                  uint256 hashPos = 0;
                                  uint256 proofPos = 0;
                                  // At each step, we compute the next hash using two values:
                                  // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
                                  //   get the next hash.
                                  // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
                                  //   `proof` array.
                                  for (uint256 i = 0; i < totalHashes; i++) {
                                      bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
                                      bytes32 b = proofFlags[i]
                                          ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                                          : proof[proofPos++];
                                      hashes[i] = _hashPair(a, b);
                                  }
                                  if (totalHashes > 0) {
                                      unchecked {
                                          return hashes[totalHashes - 1];
                                      }
                                  } else if (leavesLen > 0) {
                                      return leaves[0];
                                  } else {
                                      return proof[0];
                                  }
                              }
                              function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
                                  return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
                              }
                              function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      mstore(0x00, a)
                                      mstore(0x20, b)
                                      value := keccak256(0x00, 0x40)
                                  }
                              }
                          }
                          // SPDX-License-Identifier: MIT
                          pragma solidity 0.8.17;
                          import "./lib/Constants.sol";
                          import {
                              TakeAsk,
                              TakeBid,
                              TakeAskSingle,
                              TakeBidSingle,
                              FeeRate,
                              Order,
                              OrderType,
                              AssetType,
                              Listing
                          } from "./lib/Structs.sol";
                          import { ISignatures } from "./interfaces/ISignatures.sol";
                          abstract contract Signatures is ISignatures {
                              string private constant _NAME = "Blur Exchange";
                              string private constant _VERSION = "1.0";
                              bytes32 private immutable _FEE_RATE_TYPEHASH;
                              bytes32 private immutable _ORDER_TYPEHASH;
                              bytes32 private immutable _DOMAIN_SEPARATOR;
                              mapping(address => uint256) public oracles;
                              mapping(address => uint256) public nonces;
                              uint256 public blockRange;
                              constructor(address proxy) {
                                  (_FEE_RATE_TYPEHASH, _ORDER_TYPEHASH, _DOMAIN_SEPARATOR) = _createTypehashes(proxy);
                              }
                              /**
                               * @notice Verify the domain separator produced during deployment of the implementation matches that of the proxy
                               */
                              function verifyDomain() public view {
                                  bytes32 eip712DomainTypehash = keccak256(
                                      bytes.concat(
                                          "EIP712Domain(",
                                          "string name,",
                                          "string version,",
                                          "uint256 chainId,",
                                          "address verifyingContract",
                                          ")"
                                      )
                                  );
                                  bytes32 domainSeparator = _hashDomain(
                                      eip712DomainTypehash,
                                      keccak256(bytes(_NAME)),
                                      keccak256(bytes(_VERSION)),
                                      address(this)
                                  );
                                  if (_DOMAIN_SEPARATOR != domainSeparator) {
                                      revert InvalidDomain();
                                  }
                              }
                              /**
                               * @notice Return version and domain separator
                               */
                              function information() external view returns (string memory version, bytes32 domainSeparator) {
                                  version = _VERSION;
                                  domainSeparator = _DOMAIN_SEPARATOR;
                              }
                              /**
                               * @notice Create a hash of TakeAsk calldata with an approved caller
                               * @param inputs TakeAsk inputs
                               * @param _caller Address approved to execute the calldata
                               * @return Calldata hash
                               */
                              function hashTakeAsk(TakeAsk memory inputs, address _caller) external pure returns (bytes32) {
                                  return _hashCalldata(_caller);
                              }
                              /**
                               * @notice Create a hash of TakeBid calldata with an approved caller
                               * @param inputs TakeBid inputs
                               * @param _caller Address approved to execute the calldata
                               * @return Calldata hash
                               */
                              function hashTakeBid(TakeBid memory inputs, address _caller) external pure returns (bytes32) {
                                  return _hashCalldata(_caller);
                              }
                              /**
                               * @notice Create a hash of TakeAskSingle calldata with an approved caller
                               * @param inputs TakeAskSingle inputs
                               * @param _caller Address approved to execute the calldata
                               * @return Calldata hash
                               */
                              function hashTakeAskSingle(
                                  TakeAskSingle memory inputs,
                                  address _caller
                              ) external pure returns (bytes32) {
                                  return _hashCalldata(_caller);
                              }
                              /**
                               * @notice Create a hash of TakeBidSingle calldata with an approved caller
                               * @param inputs TakeBidSingle inputs
                               * @param _caller Address approved to execute the calldata
                               * @return Calldata hash
                               */
                              function hashTakeBidSingle(
                                  TakeBidSingle memory inputs,
                                  address _caller
                              ) external pure returns (bytes32) {
                                  return _hashCalldata(_caller);
                              }
                              /**
                               * @notice Create an EIP712 hash of an Order
                               * @dev Includes two additional parameters not in the struct (orderType, nonce)
                               * @param order Order to hash
                               * @param orderType OrderType of the Order
                               * @return Order EIP712 hash
                               */
                              function hashOrder(Order memory order, OrderType orderType) public view returns (bytes32) {
                                  return
                                      keccak256(
                                          abi.encode(
                                              _ORDER_TYPEHASH,
                                              order.trader,
                                              order.collection,
                                              order.listingsRoot,
                                              order.numberOfListings,
                                              order.expirationTime,
                                              order.assetType,
                                              _hashFeeRate(order.makerFee),
                                              order.salt,
                                              orderType,
                                              nonces[order.trader]
                                          )
                                      );
                              }
                              /**
                               * @notice Create a hash of a Listing struct
                               * @param listing Listing to hash
                               * @return Listing hash
                               */
                              function hashListing(Listing memory listing) public pure returns (bytes32) {
                                  return keccak256(abi.encode(listing.index, listing.tokenId, listing.amount, listing.price));
                              }
                              /**
                               * @notice Create a hash of calldata with an approved caller
                               * @param _caller Address approved to execute the calldata
                               * @return hash Calldata hash
                               */
                              function _hashCalldata(address _caller) internal pure returns (bytes32 hash) {
                                  assembly {
                                      let nextPointer := mload(0x40)
                                      let size := add(sub(nextPointer, 0x80), 0x20)
                                      mstore(nextPointer, _caller)
                                      hash := keccak256(0x80, size)
                                  }
                              }
                              /**
                               * @notice Create an EIP712 hash of a FeeRate struct
                               * @param feeRate FeeRate to hash
                               * @return FeeRate EIP712 hash
                               */
                              function _hashFeeRate(FeeRate memory feeRate) private view returns (bytes32) {
                                  return keccak256(abi.encode(_FEE_RATE_TYPEHASH, feeRate.recipient, feeRate.rate));
                              }
                              /**
                               * @notice Create an EIP712 hash to sign
                               * @param hash Primary EIP712 object hash
                               * @return EIP712 hash
                               */
                              function _hashToSign(bytes32 hash) private view returns (bytes32) {
                                  return keccak256(bytes.concat(bytes2(0x1901), _DOMAIN_SEPARATOR, hash));
                              }
                              /**
                               * @notice Generate all EIP712 Typehashes
                               */
                              function _createTypehashes(
                                  address proxy
                              )
                                  private
                                  view
                                  returns (bytes32 feeRateTypehash, bytes32 orderTypehash, bytes32 domainSeparator)
                              {
                                  bytes32 eip712DomainTypehash = keccak256(
                                      bytes.concat(
                                          "EIP712Domain(",
                                          "string name,",
                                          "string version,",
                                          "uint256 chainId,",
                                          "address verifyingContract",
                                          ")"
                                      )
                                  );
                                  bytes memory feeRateTypestring = "FeeRate(address recipient,uint16 rate)";
                                  orderTypehash = keccak256(
                                      bytes.concat(
                                          "Order(",
                                          "address trader,",
                                          "address collection,",
                                          "bytes32 listingsRoot,",
                                          "uint256 numberOfListings,",
                                          "uint256 expirationTime,",
                                          "uint8 assetType,",
                                          "FeeRate makerFee,",
                                          "uint256 salt,",
                                          "uint8 orderType,",
                                          "uint256 nonce",
                                          ")",
                                          feeRateTypestring
                                      )
                                  );
                                  feeRateTypehash = keccak256(feeRateTypestring);
                                  domainSeparator = _hashDomain(
                                      eip712DomainTypehash,
                                      keccak256(bytes(_NAME)),
                                      keccak256(bytes(_VERSION)),
                                      proxy
                                  );
                              }
                              /**
                               * @notice Create an EIP712 domain separator
                               * @param eip712DomainTypehash Typehash of the EIP712Domain struct
                               * @param nameHash Hash of the contract name
                               * @param versionHash Hash of the version string
                               * @param proxy Address of the proxy this implementation will be behind
                               * @return EIP712Domain hash
                               */
                              function _hashDomain(
                                  bytes32 eip712DomainTypehash,
                                  bytes32 nameHash,
                                  bytes32 versionHash,
                                  address proxy
                              ) private view returns (bytes32) {
                                  return
                                      keccak256(
                                          abi.encode(eip712DomainTypehash, nameHash, versionHash, block.chainid, proxy)
                                      );
                              }
                              /**
                               * @notice Verify EIP712 signature
                               * @param signer Address of the alleged signer
                               * @param hash EIP712 hash
                               * @param signatures Packed bytes array of order signatures
                               * @param index Index of the signature to verify
                               * @return authorized Validity of the signature
                               */
                              function _verifyAuthorization(
                                  address signer,
                                  bytes32 hash,
                                  bytes memory signatures,
                                  uint256 index
                              ) internal view returns (bool authorized) {
                                  bytes32 hashToSign = _hashToSign(hash);
                                  bytes32 r;
                                  bytes32 s;
                                  uint8 v;
                                  assembly {
                                      let signatureOffset := add(add(signatures, One_word), mul(Signatures_size, index))
                                      r := mload(signatureOffset)
                                      s := mload(add(signatureOffset, Signatures_s_offset))
                                      v := shr(Bytes1_shift, mload(add(signatureOffset, Signatures_v_offset)))
                                  }
                                  authorized = _verify(signer, hashToSign, v, r, s);
                              }
                              modifier verifyOracleSignature(bytes32 hash, bytes calldata oracleSignature) {
                                  bytes32 r;
                                  bytes32 s;
                                  uint8 v;
                                  uint32 blockNumber;
                                  address oracle;
                                  assembly {
                                      let signatureOffset := oracleSignature.offset
                                      r := calldataload(signatureOffset)
                                      s := calldataload(add(signatureOffset, OracleSignatures_s_offset))
                                      v := shr(Bytes1_shift, calldataload(add(signatureOffset, OracleSignatures_v_offset)))
                                      blockNumber := shr(
                                          Bytes4_shift,
                                          calldataload(add(signatureOffset, OracleSignatures_blockNumber_offset))
                                      )
                                      oracle := shr(
                                          Bytes20_shift,
                                          calldataload(add(signatureOffset, OracleSignatures_oracle_offset))
                                      )
                                  }
                                  if (blockNumber + blockRange < block.number) {
                                      revert ExpiredOracleSignature();
                                  }
                                  if (oracles[oracle] == 0) {
                                      revert UnauthorizedOracle();
                                  }
                                  if (!_verify(oracle, keccak256(abi.encodePacked(hash, blockNumber)), v, r, s)) {
                                      revert InvalidOracleSignature();
                                  }
                                  _;
                              }
                              /**
                               * @notice Verify signature of digest
                               * @param signer Address of expected signer
                               * @param digest Signature digest
                               * @param v v parameter
                               * @param r r parameter
                               * @param s s parameter
                               */
                              function _verify(
                                  address signer,
                                  bytes32 digest,
                                  uint8 v,
                                  bytes32 r,
                                  bytes32 s
                              ) private pure returns (bool valid) {
                                  address recoveredSigner = ecrecover(digest, v, r, s);
                                  if (recoveredSigner != address(0) && recoveredSigner == signer) {
                                      valid = true;
                                  }
                              }
                              uint256[47] private __gap;
                          }
                          // SPDX-License-Identifier: MIT
                          pragma solidity 0.8.17;
                          import { FeeRate } from "../lib/Structs.sol";
                          interface IValidation {
                              function protocolFee() external view returns (address, uint16);
                              function amountTaken(address user, bytes32 hash, uint256 listingIndex) external view returns (uint256);
                          }
                          // SPDX-License-Identifier: MIT
                          pragma solidity 0.8.17;
                          import {
                              TakeAsk,
                              TakeBid,
                              TakeAskSingle,
                              TakeBidSingle,
                              Order,
                              OrderType,
                              Listing
                          } from "../lib/Structs.sol";
                          interface ISignatures {
                              error Unauthorized();
                              error ExpiredOracleSignature();
                              error UnauthorizedOracle();
                              error InvalidOracleSignature();
                              error InvalidDomain();
                              function oracles(address oracle) external view returns (uint256);
                              function nonces(address user) external view returns (uint256);
                              function blockRange() external view returns (uint256);
                              function verifyDomain() external view;
                              function information() external view returns (string memory version, bytes32 domainSeparator);
                              function hashListing(Listing memory listing) external pure returns (bytes32);
                              function hashOrder(Order memory order, OrderType orderType) external view returns (bytes32);
                              function hashTakeAsk(TakeAsk memory inputs, address _caller) external pure returns (bytes32);
                              function hashTakeBid(TakeBid memory inputs, address _caller) external pure returns (bytes32);
                              function hashTakeAskSingle(TakeAskSingle memory inputs, address _caller) external pure returns (bytes32);
                              function hashTakeBidSingle(TakeBidSingle memory inputs, address _caller) external pure returns (bytes32);
                          }
                          

                          File 10 of 10: Delegate
                          // SPDX-License-Identifier: MIT
                          pragma solidity 0.8.17;
                          import { ERC721 } from "lib/solmate/src/tokens/ERC721.sol";
                          import { ERC1155 } from "lib/solmate/src/tokens/ERC1155.sol";
                          import { ERC20 } from "lib/solmate/src/tokens/ERC20.sol";
                          import "./lib/Constants.sol";
                          import { AssetType, OrderType, Transfer } from "./lib/Structs.sol";
                          contract Delegate {
                              error Unauthorized();
                              error InvalidLength();
                              address private immutable _EXCHANGE;
                              constructor(address exchange) {
                                  _EXCHANGE = exchange;
                              }
                              modifier onlyApproved() {
                                  if (msg.sender != _EXCHANGE) {
                                      revert Unauthorized();
                                  }
                                  _;
                              }
                              function transfer(
                                  address taker,
                                  OrderType orderType,
                                  Transfer[] calldata transfers,
                                  uint256 length
                              ) external onlyApproved returns (bool[] memory successful) {
                                  if (transfers.length < length) {
                                      revert InvalidLength();
                                  }
                                  successful = new bool[](length);
                                  for (uint256 i; i < length; ) {
                                      assembly {
                                          let calldataPointer := mload(0x40)
                                          let transfersPointer := add(transfers.offset, mul(Transfer_size, i))
                                          let assetType := calldataload(add(transfersPointer, Transfer_assetType_offset))
                                          switch assetType
                                          case 0 {
                                              // AssetType_ERC721
                                              mstore(calldataPointer, ERC721_safeTransferFrom_selector)
                                              switch orderType
                                              case 0 {
                                                  // OrderType_ASK; taker is recipient
                                                  mstore(add(calldataPointer, ERC721_safeTransferFrom_to_offset), taker)
                                                  mstore(
                                                      add(calldataPointer, ERC721_safeTransferFrom_from_offset),
                                                      calldataload(add(transfersPointer, Transfer_trader_offset))
                                                  )
                                              }
                                              case 1 {
                                                  // OrderType_BID; taker is sender
                                                  mstore(add(calldataPointer, ERC721_safeTransferFrom_from_offset), taker)
                                                  mstore(
                                                      add(calldataPointer, ERC721_safeTransferFrom_to_offset),
                                                      calldataload(add(transfersPointer, Transfer_trader_offset))
                                                  )
                                              }
                                              default {
                                                  revert(0, 0)
                                              }
                                              mstore(
                                                  add(calldataPointer, ERC721_safeTransferFrom_id_offset),
                                                  calldataload(add(transfersPointer, Transfer_id_offset))
                                              )
                                              let collection := calldataload(
                                                  add(transfersPointer, Transfer_collection_offset)
                                              )
                                              let success := call(
                                                  gas(),
                                                  collection,
                                                  0,
                                                  calldataPointer,
                                                  ERC721_safeTransferFrom_size,
                                                  0,
                                                  0
                                              )
                                              mstore(add(add(successful, 0x20), mul(0x20, i)), success)
                                          }
                                          case 1 {
                                              // AssetType_ERC1155
                                              mstore(calldataPointer, ERC1155_safeTransferFrom_selector)
                                              switch orderType
                                              case 0 {
                                                  // OrderType_ASK; taker is recipient
                                                  mstore(
                                                      add(calldataPointer, ERC1155_safeTransferFrom_from_offset),
                                                      calldataload(
                                                          add(
                                                              transfersPointer,
                                                              Transfer_trader_offset
                                                          )
                                                      )
                                                  )
                                                  mstore(add(calldataPointer, ERC1155_safeTransferFrom_to_offset), taker)
                                              }
                                              case 1 {
                                                  // OrderType_BID; taker is sender
                                                  mstore(
                                                      add(calldataPointer, ERC1155_safeTransferFrom_to_offset),
                                                      calldataload(
                                                          add(
                                                              transfersPointer,
                                                              Transfer_trader_offset
                                                          )
                                                      )
                                                  )
                                                  mstore(add(calldataPointer, ERC1155_safeTransferFrom_from_offset), taker)
                                              }
                                              default {
                                                  revert(0, 0)
                                              }
                                              mstore(add(calldataPointer, ERC1155_safeTransferFrom_data_pointer_offset), 0xa0)
                                              mstore(add(calldataPointer, ERC1155_safeTransferFrom_data_offset), 0)
                                              mstore(
                                                  add(calldataPointer, ERC1155_safeTransferFrom_id_offset),
                                                  calldataload(
                                                      add(transfersPointer, Transfer_id_offset)
                                                  )
                                              )
                                              mstore(
                                                  add(calldataPointer, ERC1155_safeTransferFrom_amount_offset),
                                                  calldataload(
                                                      add(
                                                          transfersPointer,
                                                          Transfer_amount_offset
                                                      )
                                                  )
                                              )
                                              let collection := calldataload(
                                                  add(
                                                      transfersPointer,
                                                      Transfer_collection_offset
                                                  )
                                              )
                                              let success := call(
                                                  gas(),
                                                  collection,
                                                  0,
                                                  calldataPointer,
                                                  ERC1155_safeTransferFrom_size,
                                                  0,
                                                  0
                                              )
                                              mstore(add(add(successful, 0x20), mul(0x20, i)), success)
                                          }
                                          default {
                                              revert(0, 0)
                                          }
                                      }
                                      unchecked {
                                          ++i;
                                      }
                                  }
                              }
                          }
                          // SPDX-License-Identifier: AGPL-3.0-only
                          pragma solidity >=0.8.0;
                          /// @notice Modern, minimalist, and gas efficient ERC-721 implementation.
                          /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC721.sol)
                          abstract contract ERC721 {
                              /*//////////////////////////////////////////////////////////////
                                                           EVENTS
                              //////////////////////////////////////////////////////////////*/
                              event Transfer(address indexed from, address indexed to, uint256 indexed id);
                              event Approval(address indexed owner, address indexed spender, uint256 indexed id);
                              event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
                              /*//////////////////////////////////////////////////////////////
                                                   METADATA STORAGE/LOGIC
                              //////////////////////////////////////////////////////////////*/
                              string public name;
                              string public symbol;
                              function tokenURI(uint256 id) public view virtual returns (string memory);
                              /*//////////////////////////////////////////////////////////////
                                                ERC721 BALANCE/OWNER STORAGE
                              //////////////////////////////////////////////////////////////*/
                              mapping(uint256 => address) internal _ownerOf;
                              mapping(address => uint256) internal _balanceOf;
                              function ownerOf(uint256 id) public view virtual returns (address owner) {
                                  require((owner = _ownerOf[id]) != address(0), "NOT_MINTED");
                              }
                              function balanceOf(address owner) public view virtual returns (uint256) {
                                  require(owner != address(0), "ZERO_ADDRESS");
                                  return _balanceOf[owner];
                              }
                              /*//////////////////////////////////////////////////////////////
                                                   ERC721 APPROVAL STORAGE
                              //////////////////////////////////////////////////////////////*/
                              mapping(uint256 => address) public getApproved;
                              mapping(address => mapping(address => bool)) public isApprovedForAll;
                              /*//////////////////////////////////////////////////////////////
                                                         CONSTRUCTOR
                              //////////////////////////////////////////////////////////////*/
                              constructor(string memory _name, string memory _symbol) {
                                  name = _name;
                                  symbol = _symbol;
                              }
                              /*//////////////////////////////////////////////////////////////
                                                        ERC721 LOGIC
                              //////////////////////////////////////////////////////////////*/
                              function approve(address spender, uint256 id) public virtual {
                                  address owner = _ownerOf[id];
                                  require(msg.sender == owner || isApprovedForAll[owner][msg.sender], "NOT_AUTHORIZED");
                                  getApproved[id] = spender;
                                  emit Approval(owner, spender, id);
                              }
                              function setApprovalForAll(address operator, bool approved) public virtual {
                                  isApprovedForAll[msg.sender][operator] = approved;
                                  emit ApprovalForAll(msg.sender, operator, approved);
                              }
                              function transferFrom(
                                  address from,
                                  address to,
                                  uint256 id
                              ) public virtual {
                                  require(from == _ownerOf[id], "WRONG_FROM");
                                  require(to != address(0), "INVALID_RECIPIENT");
                                  require(
                                      msg.sender == from || isApprovedForAll[from][msg.sender] || msg.sender == getApproved[id],
                                      "NOT_AUTHORIZED"
                                  );
                                  // Underflow of the sender's balance is impossible because we check for
                                  // ownership above and the recipient's balance can't realistically overflow.
                                  unchecked {
                                      _balanceOf[from]--;
                                      _balanceOf[to]++;
                                  }
                                  _ownerOf[id] = to;
                                  delete getApproved[id];
                                  emit Transfer(from, to, id);
                              }
                              function safeTransferFrom(
                                  address from,
                                  address to,
                                  uint256 id
                              ) public virtual {
                                  transferFrom(from, to, id);
                                  require(
                                      to.code.length == 0 ||
                                          ERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, "") ==
                                          ERC721TokenReceiver.onERC721Received.selector,
                                      "UNSAFE_RECIPIENT"
                                  );
                              }
                              function safeTransferFrom(
                                  address from,
                                  address to,
                                  uint256 id,
                                  bytes calldata data
                              ) public virtual {
                                  transferFrom(from, to, id);
                                  require(
                                      to.code.length == 0 ||
                                          ERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, data) ==
                                          ERC721TokenReceiver.onERC721Received.selector,
                                      "UNSAFE_RECIPIENT"
                                  );
                              }
                              /*//////////////////////////////////////////////////////////////
                                                        ERC165 LOGIC
                              //////////////////////////////////////////////////////////////*/
                              function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
                                  return
                                      interfaceId == 0x01ffc9a7 || // ERC165 Interface ID for ERC165
                                      interfaceId == 0x80ac58cd || // ERC165 Interface ID for ERC721
                                      interfaceId == 0x5b5e139f; // ERC165 Interface ID for ERC721Metadata
                              }
                              /*//////////////////////////////////////////////////////////////
                                                  INTERNAL MINT/BURN LOGIC
                              //////////////////////////////////////////////////////////////*/
                              function _mint(address to, uint256 id) internal virtual {
                                  require(to != address(0), "INVALID_RECIPIENT");
                                  require(_ownerOf[id] == address(0), "ALREADY_MINTED");
                                  // Counter overflow is incredibly unrealistic.
                                  unchecked {
                                      _balanceOf[to]++;
                                  }
                                  _ownerOf[id] = to;
                                  emit Transfer(address(0), to, id);
                              }
                              function _burn(uint256 id) internal virtual {
                                  address owner = _ownerOf[id];
                                  require(owner != address(0), "NOT_MINTED");
                                  // Ownership check above ensures no underflow.
                                  unchecked {
                                      _balanceOf[owner]--;
                                  }
                                  delete _ownerOf[id];
                                  delete getApproved[id];
                                  emit Transfer(owner, address(0), id);
                              }
                              /*//////////////////////////////////////////////////////////////
                                                  INTERNAL SAFE MINT LOGIC
                              //////////////////////////////////////////////////////////////*/
                              function _safeMint(address to, uint256 id) internal virtual {
                                  _mint(to, id);
                                  require(
                                      to.code.length == 0 ||
                                          ERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, "") ==
                                          ERC721TokenReceiver.onERC721Received.selector,
                                      "UNSAFE_RECIPIENT"
                                  );
                              }
                              function _safeMint(
                                  address to,
                                  uint256 id,
                                  bytes memory data
                              ) internal virtual {
                                  _mint(to, id);
                                  require(
                                      to.code.length == 0 ||
                                          ERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, data) ==
                                          ERC721TokenReceiver.onERC721Received.selector,
                                      "UNSAFE_RECIPIENT"
                                  );
                              }
                          }
                          /// @notice A generic interface for a contract which properly accepts ERC721 tokens.
                          /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC721.sol)
                          abstract contract ERC721TokenReceiver {
                              function onERC721Received(
                                  address,
                                  address,
                                  uint256,
                                  bytes calldata
                              ) external virtual returns (bytes4) {
                                  return ERC721TokenReceiver.onERC721Received.selector;
                              }
                          }
                          // SPDX-License-Identifier: AGPL-3.0-only
                          pragma solidity >=0.8.0;
                          /// @notice Minimalist and gas efficient standard ERC1155 implementation.
                          /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC1155.sol)
                          abstract contract ERC1155 {
                              /*//////////////////////////////////////////////////////////////
                                                           EVENTS
                              //////////////////////////////////////////////////////////////*/
                              event TransferSingle(
                                  address indexed operator,
                                  address indexed from,
                                  address indexed to,
                                  uint256 id,
                                  uint256 amount
                              );
                              event TransferBatch(
                                  address indexed operator,
                                  address indexed from,
                                  address indexed to,
                                  uint256[] ids,
                                  uint256[] amounts
                              );
                              event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
                              event URI(string value, uint256 indexed id);
                              /*//////////////////////////////////////////////////////////////
                                                       ERC1155 STORAGE
                              //////////////////////////////////////////////////////////////*/
                              mapping(address => mapping(uint256 => uint256)) public balanceOf;
                              mapping(address => mapping(address => bool)) public isApprovedForAll;
                              /*//////////////////////////////////////////////////////////////
                                                       METADATA LOGIC
                              //////////////////////////////////////////////////////////////*/
                              function uri(uint256 id) public view virtual returns (string memory);
                              /*//////////////////////////////////////////////////////////////
                                                        ERC1155 LOGIC
                              //////////////////////////////////////////////////////////////*/
                              function setApprovalForAll(address operator, bool approved) public virtual {
                                  isApprovedForAll[msg.sender][operator] = approved;
                                  emit ApprovalForAll(msg.sender, operator, approved);
                              }
                              function safeTransferFrom(
                                  address from,
                                  address to,
                                  uint256 id,
                                  uint256 amount,
                                  bytes calldata data
                              ) public virtual {
                                  require(msg.sender == from || isApprovedForAll[from][msg.sender], "NOT_AUTHORIZED");
                                  balanceOf[from][id] -= amount;
                                  balanceOf[to][id] += amount;
                                  emit TransferSingle(msg.sender, from, to, id, amount);
                                  require(
                                      to.code.length == 0
                                          ? to != address(0)
                                          : ERC1155TokenReceiver(to).onERC1155Received(msg.sender, from, id, amount, data) ==
                                              ERC1155TokenReceiver.onERC1155Received.selector,
                                      "UNSAFE_RECIPIENT"
                                  );
                              }
                              function safeBatchTransferFrom(
                                  address from,
                                  address to,
                                  uint256[] calldata ids,
                                  uint256[] calldata amounts,
                                  bytes calldata data
                              ) public virtual {
                                  require(ids.length == amounts.length, "LENGTH_MISMATCH");
                                  require(msg.sender == from || isApprovedForAll[from][msg.sender], "NOT_AUTHORIZED");
                                  // Storing these outside the loop saves ~15 gas per iteration.
                                  uint256 id;
                                  uint256 amount;
                                  for (uint256 i = 0; i < ids.length; ) {
                                      id = ids[i];
                                      amount = amounts[i];
                                      balanceOf[from][id] -= amount;
                                      balanceOf[to][id] += amount;
                                      // An array can't have a total length
                                      // larger than the max uint256 value.
                                      unchecked {
                                          ++i;
                                      }
                                  }
                                  emit TransferBatch(msg.sender, from, to, ids, amounts);
                                  require(
                                      to.code.length == 0
                                          ? to != address(0)
                                          : ERC1155TokenReceiver(to).onERC1155BatchReceived(msg.sender, from, ids, amounts, data) ==
                                              ERC1155TokenReceiver.onERC1155BatchReceived.selector,
                                      "UNSAFE_RECIPIENT"
                                  );
                              }
                              function balanceOfBatch(address[] calldata owners, uint256[] calldata ids)
                                  public
                                  view
                                  virtual
                                  returns (uint256[] memory balances)
                              {
                                  require(owners.length == ids.length, "LENGTH_MISMATCH");
                                  balances = new uint256[](owners.length);
                                  // Unchecked because the only math done is incrementing
                                  // the array index counter which cannot possibly overflow.
                                  unchecked {
                                      for (uint256 i = 0; i < owners.length; ++i) {
                                          balances[i] = balanceOf[owners[i]][ids[i]];
                                      }
                                  }
                              }
                              /*//////////////////////////////////////////////////////////////
                                                        ERC165 LOGIC
                              //////////////////////////////////////////////////////////////*/
                              function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
                                  return
                                      interfaceId == 0x01ffc9a7 || // ERC165 Interface ID for ERC165
                                      interfaceId == 0xd9b67a26 || // ERC165 Interface ID for ERC1155
                                      interfaceId == 0x0e89341c; // ERC165 Interface ID for ERC1155MetadataURI
                              }
                              /*//////////////////////////////////////////////////////////////
                                                  INTERNAL MINT/BURN LOGIC
                              //////////////////////////////////////////////////////////////*/
                              function _mint(
                                  address to,
                                  uint256 id,
                                  uint256 amount,
                                  bytes memory data
                              ) internal virtual {
                                  balanceOf[to][id] += amount;
                                  emit TransferSingle(msg.sender, address(0), to, id, amount);
                                  require(
                                      to.code.length == 0
                                          ? to != address(0)
                                          : ERC1155TokenReceiver(to).onERC1155Received(msg.sender, address(0), id, amount, data) ==
                                              ERC1155TokenReceiver.onERC1155Received.selector,
                                      "UNSAFE_RECIPIENT"
                                  );
                              }
                              function _batchMint(
                                  address to,
                                  uint256[] memory ids,
                                  uint256[] memory amounts,
                                  bytes memory data
                              ) internal virtual {
                                  uint256 idsLength = ids.length; // Saves MLOADs.
                                  require(idsLength == amounts.length, "LENGTH_MISMATCH");
                                  for (uint256 i = 0; i < idsLength; ) {
                                      balanceOf[to][ids[i]] += amounts[i];
                                      // An array can't have a total length
                                      // larger than the max uint256 value.
                                      unchecked {
                                          ++i;
                                      }
                                  }
                                  emit TransferBatch(msg.sender, address(0), to, ids, amounts);
                                  require(
                                      to.code.length == 0
                                          ? to != address(0)
                                          : ERC1155TokenReceiver(to).onERC1155BatchReceived(msg.sender, address(0), ids, amounts, data) ==
                                              ERC1155TokenReceiver.onERC1155BatchReceived.selector,
                                      "UNSAFE_RECIPIENT"
                                  );
                              }
                              function _batchBurn(
                                  address from,
                                  uint256[] memory ids,
                                  uint256[] memory amounts
                              ) internal virtual {
                                  uint256 idsLength = ids.length; // Saves MLOADs.
                                  require(idsLength == amounts.length, "LENGTH_MISMATCH");
                                  for (uint256 i = 0; i < idsLength; ) {
                                      balanceOf[from][ids[i]] -= amounts[i];
                                      // An array can't have a total length
                                      // larger than the max uint256 value.
                                      unchecked {
                                          ++i;
                                      }
                                  }
                                  emit TransferBatch(msg.sender, from, address(0), ids, amounts);
                              }
                              function _burn(
                                  address from,
                                  uint256 id,
                                  uint256 amount
                              ) internal virtual {
                                  balanceOf[from][id] -= amount;
                                  emit TransferSingle(msg.sender, from, address(0), id, amount);
                              }
                          }
                          /// @notice A generic interface for a contract which properly accepts ERC1155 tokens.
                          /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC1155.sol)
                          abstract contract ERC1155TokenReceiver {
                              function onERC1155Received(
                                  address,
                                  address,
                                  uint256,
                                  uint256,
                                  bytes calldata
                              ) external virtual returns (bytes4) {
                                  return ERC1155TokenReceiver.onERC1155Received.selector;
                              }
                              function onERC1155BatchReceived(
                                  address,
                                  address,
                                  uint256[] calldata,
                                  uint256[] calldata,
                                  bytes calldata
                              ) external virtual returns (bytes4) {
                                  return ERC1155TokenReceiver.onERC1155BatchReceived.selector;
                              }
                          }
                          // SPDX-License-Identifier: AGPL-3.0-only
                          pragma solidity >=0.8.0;
                          /// @notice Modern and gas efficient ERC20 + EIP-2612 implementation.
                          /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol)
                          /// @author Modified from Uniswap (https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol)
                          /// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it.
                          abstract contract ERC20 {
                              /*//////////////////////////////////////////////////////////////
                                                           EVENTS
                              //////////////////////////////////////////////////////////////*/
                              event Transfer(address indexed from, address indexed to, uint256 amount);
                              event Approval(address indexed owner, address indexed spender, uint256 amount);
                              /*//////////////////////////////////////////////////////////////
                                                      METADATA STORAGE
                              //////////////////////////////////////////////////////////////*/
                              string public name;
                              string public symbol;
                              uint8 public immutable decimals;
                              /*//////////////////////////////////////////////////////////////
                                                        ERC20 STORAGE
                              //////////////////////////////////////////////////////////////*/
                              uint256 public totalSupply;
                              mapping(address => uint256) public balanceOf;
                              mapping(address => mapping(address => uint256)) public allowance;
                              /*//////////////////////////////////////////////////////////////
                                                      EIP-2612 STORAGE
                              //////////////////////////////////////////////////////////////*/
                              uint256 internal immutable INITIAL_CHAIN_ID;
                              bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;
                              mapping(address => uint256) public nonces;
                              /*//////////////////////////////////////////////////////////////
                                                         CONSTRUCTOR
                              //////////////////////////////////////////////////////////////*/
                              constructor(
                                  string memory _name,
                                  string memory _symbol,
                                  uint8 _decimals
                              ) {
                                  name = _name;
                                  symbol = _symbol;
                                  decimals = _decimals;
                                  INITIAL_CHAIN_ID = block.chainid;
                                  INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
                              }
                              /*//////////////////////////////////////////////////////////////
                                                         ERC20 LOGIC
                              //////////////////////////////////////////////////////////////*/
                              function approve(address spender, uint256 amount) public virtual returns (bool) {
                                  allowance[msg.sender][spender] = amount;
                                  emit Approval(msg.sender, spender, amount);
                                  return true;
                              }
                              function transfer(address to, uint256 amount) public virtual returns (bool) {
                                  balanceOf[msg.sender] -= amount;
                                  // Cannot overflow because the sum of all user
                                  // balances can't exceed the max uint256 value.
                                  unchecked {
                                      balanceOf[to] += amount;
                                  }
                                  emit Transfer(msg.sender, to, amount);
                                  return true;
                              }
                              function transferFrom(
                                  address from,
                                  address to,
                                  uint256 amount
                              ) public virtual returns (bool) {
                                  uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals.
                                  if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount;
                                  balanceOf[from] -= amount;
                                  // Cannot overflow because the sum of all user
                                  // balances can't exceed the max uint256 value.
                                  unchecked {
                                      balanceOf[to] += amount;
                                  }
                                  emit Transfer(from, to, amount);
                                  return true;
                              }
                              /*//////////////////////////////////////////////////////////////
                                                       EIP-2612 LOGIC
                              //////////////////////////////////////////////////////////////*/
                              function permit(
                                  address owner,
                                  address spender,
                                  uint256 value,
                                  uint256 deadline,
                                  uint8 v,
                                  bytes32 r,
                                  bytes32 s
                              ) public virtual {
                                  require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED");
                                  // Unchecked because the only math done is incrementing
                                  // the owner's nonce which cannot realistically overflow.
                                  unchecked {
                                      address recoveredAddress = ecrecover(
                                          keccak256(
                                              abi.encodePacked(
                                                  "\\x19\\x01",
                                                  DOMAIN_SEPARATOR(),
                                                  keccak256(
                                                      abi.encode(
                                                          keccak256(
                                                              "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
                                                          ),
                                                          owner,
                                                          spender,
                                                          value,
                                                          nonces[owner]++,
                                                          deadline
                                                      )
                                                  )
                                              )
                                          ),
                                          v,
                                          r,
                                          s
                                      );
                                      require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_SIGNER");
                                      allowance[recoveredAddress][spender] = value;
                                  }
                                  emit Approval(owner, spender, value);
                              }
                              function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
                                  return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();
                              }
                              function computeDomainSeparator() internal view virtual returns (bytes32) {
                                  return
                                      keccak256(
                                          abi.encode(
                                              keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
                                              keccak256(bytes(name)),
                                              keccak256("1"),
                                              block.chainid,
                                              address(this)
                                          )
                                      );
                              }
                              /*//////////////////////////////////////////////////////////////
                                                  INTERNAL MINT/BURN LOGIC
                              //////////////////////////////////////////////////////////////*/
                              function _mint(address to, uint256 amount) internal virtual {
                                  totalSupply += amount;
                                  // Cannot overflow because the sum of all user
                                  // balances can't exceed the max uint256 value.
                                  unchecked {
                                      balanceOf[to] += amount;
                                  }
                                  emit Transfer(address(0), to, amount);
                              }
                              function _burn(address from, uint256 amount) internal virtual {
                                  balanceOf[from] -= amount;
                                  // Cannot underflow because a user's balance
                                  // will never be larger than the total supply.
                                  unchecked {
                                      totalSupply -= amount;
                                  }
                                  emit Transfer(from, address(0), amount);
                              }
                          }
                          // SPDX-License-Identifier: MIT
                          pragma solidity 0.8.17;
                          uint256 constant Bytes1_shift = 0xf8;
                          uint256 constant Bytes4_shift = 0xe0;
                          uint256 constant Bytes20_shift = 0x60;
                          uint256 constant One_word = 0x20;
                          uint256 constant Memory_pointer = 0x40;
                          uint256 constant AssetType_ERC721 = 0;
                          uint256 constant AssetType_ERC1155 = 1;
                          uint256 constant OrderType_ASK = 0;
                          uint256 constant OrderType_BID = 1;
                          uint256 constant Pool_withdrawFrom_selector = 0x9555a94200000000000000000000000000000000000000000000000000000000;
                          uint256 constant Pool_withdrawFrom_from_offset = 0x04;
                          uint256 constant Pool_withdrawFrom_to_offset = 0x24;
                          uint256 constant Pool_withdrawFrom_amount_offset = 0x44;
                          uint256 constant Pool_withdrawFrom_size = 0x64;
                          uint256 constant Pool_deposit_selector = 0xf340fa0100000000000000000000000000000000000000000000000000000000;
                          uint256 constant Pool_deposit_user_offset = 0x04;
                          uint256 constant Pool_deposit_size = 0x24;
                          uint256 constant ERC20_transferFrom_selector = 0x23b872dd00000000000000000000000000000000000000000000000000000000;
                          uint256 constant ERC721_safeTransferFrom_selector = 0x42842e0e00000000000000000000000000000000000000000000000000000000;
                          uint256 constant ERC1155_safeTransferFrom_selector = 0xf242432a00000000000000000000000000000000000000000000000000000000;
                          uint256 constant ERC20_transferFrom_size = 0x64;
                          uint256 constant ERC721_safeTransferFrom_size = 0x64;
                          uint256 constant ERC1155_safeTransferFrom_size = 0xc4;
                          uint256 constant OracleSignatures_size = 0x59;
                          uint256 constant OracleSignatures_s_offset = 0x20;
                          uint256 constant OracleSignatures_v_offset = 0x40;
                          uint256 constant OracleSignatures_blockNumber_offset = 0x41;
                          uint256 constant OracleSignatures_oracle_offset = 0x45;
                          uint256 constant Signatures_size = 0x41;
                          uint256 constant Signatures_s_offset = 0x20;
                          uint256 constant Signatures_v_offset = 0x40;
                          uint256 constant ERC20_transferFrom_from_offset = 0x4;
                          uint256 constant ERC20_transferFrom_to_offset = 0x24;
                          uint256 constant ERC20_transferFrom_amount_offset = 0x44;
                          uint256 constant ERC721_safeTransferFrom_from_offset = 0x4;
                          uint256 constant ERC721_safeTransferFrom_to_offset = 0x24;
                          uint256 constant ERC721_safeTransferFrom_id_offset = 0x44;
                          uint256 constant ERC1155_safeTransferFrom_from_offset = 0x4;
                          uint256 constant ERC1155_safeTransferFrom_to_offset = 0x24;
                          uint256 constant ERC1155_safeTransferFrom_id_offset = 0x44;
                          uint256 constant ERC1155_safeTransferFrom_amount_offset = 0x64;
                          uint256 constant ERC1155_safeTransferFrom_data_pointer_offset = 0x84;
                          uint256 constant ERC1155_safeTransferFrom_data_offset = 0xa4;
                          uint256 constant Delegate_transfer_selector = 0xa1ccb98e00000000000000000000000000000000000000000000000000000000;
                          uint256 constant Delegate_transfer_calldata_offset = 0x1c;
                          uint256 constant Order_size = 0x100;
                          uint256 constant Order_trader_offset = 0x00;
                          uint256 constant Order_collection_offset = 0x20;
                          uint256 constant Order_listingsRoot_offset = 0x40;
                          uint256 constant Order_numberOfListings_offset = 0x60;
                          uint256 constant Order_expirationTime_offset = 0x80;
                          uint256 constant Order_assetType_offset = 0xa0;
                          uint256 constant Order_makerFee_offset = 0xc0;
                          uint256 constant Order_salt_offset = 0xe0;
                          uint256 constant Exchange_size = 0x80;
                          uint256 constant Exchange_askIndex_offset = 0x00;
                          uint256 constant Exchange_proof_offset = 0x20;
                          uint256 constant Exchange_maker_offset = 0x40;
                          uint256 constant Exchange_taker_offset = 0x60;
                          uint256 constant BidExchange_size = 0x80;
                          uint256 constant BidExchange_askIndex_offset = 0x00;
                          uint256 constant BidExchange_proof_offset = 0x20;
                          uint256 constant BidExchange_maker_offset = 0x40;
                          uint256 constant BidExchange_taker_offset = 0x60;
                          uint256 constant Listing_size = 0x80;
                          uint256 constant Listing_index_offset = 0x00;
                          uint256 constant Listing_tokenId_offset = 0x20;
                          uint256 constant Listing_amount_offset = 0x40;
                          uint256 constant Listing_price_offset = 0x60;
                          uint256 constant Taker_size = 0x40;
                          uint256 constant Taker_tokenId_offset = 0x00;
                          uint256 constant Taker_amount_offset = 0x20;
                          uint256 constant StateUpdate_size = 0x80;
                          uint256 constant StateUpdate_salt_offset = 0x20;
                          uint256 constant StateUpdate_leaf_offset = 0x40;
                          uint256 constant StateUpdate_value_offset = 0x60;
                          uint256 constant Transfer_size = 0xa0;
                          uint256 constant Transfer_trader_offset = 0x00;
                          uint256 constant Transfer_id_offset = 0x20;
                          uint256 constant Transfer_amount_offset = 0x40;
                          uint256 constant Transfer_collection_offset = 0x60;
                          uint256 constant Transfer_assetType_offset = 0x80;
                          uint256 constant ExecutionBatch_selector_offset = 0x20;
                          uint256 constant ExecutionBatch_calldata_offset = 0x40;
                          uint256 constant ExecutionBatch_base_size = 0xa0; // size of the executionBatch without the flattened dynamic elements
                          uint256 constant ExecutionBatch_taker_offset = 0x00;
                          uint256 constant ExecutionBatch_orderType_offset = 0x20;
                          uint256 constant ExecutionBatch_transfers_pointer_offset = 0x40;
                          uint256 constant ExecutionBatch_length_offset = 0x60;
                          uint256 constant ExecutionBatch_transfers_offset = 0x80;
                          // SPDX-License-Identifier: MIT
                          pragma solidity ^0.8.17;
                          struct TakeAsk {
                              Order[] orders;
                              Exchange[] exchanges;
                              FeeRate takerFee;
                              bytes signatures;
                              address tokenRecipient;
                          }
                          struct TakeAskSingle {
                              Order order;
                              Exchange exchange;
                              FeeRate takerFee;
                              bytes signature;
                              address tokenRecipient;
                          }
                          struct TakeBid {
                              Order[] orders;
                              Exchange[] exchanges;
                              FeeRate takerFee;
                              bytes signatures;
                          }
                          struct TakeBidSingle {
                              Order order;
                              Exchange exchange;
                              FeeRate takerFee;
                              bytes signature;
                          }
                          enum AssetType {
                              ERC721,
                              ERC1155
                          }
                          enum OrderType {
                              ASK,
                              BID
                          }
                          struct Exchange { // Size: 0x80
                              uint256 index; // 0x00
                              bytes32[] proof; // 0x20
                              Listing listing; // 0x40
                              Taker taker; // 0x60
                          }
                          struct Listing { // Size: 0x80
                              uint256 index; // 0x00
                              uint256 tokenId; // 0x20
                              uint256 amount; // 0x40
                              uint256 price; // 0x60
                          }
                          struct Taker { // Size: 0x40
                              uint256 tokenId; // 0x00
                              uint256 amount; // 0x20
                          }
                          struct Order { // Size: 0x100
                              address trader; // 0x00
                              address collection; // 0x20
                              bytes32 listingsRoot; // 0x40
                              uint256 numberOfListings; // 0x60
                              uint256 expirationTime; // 0x80
                              AssetType assetType; // 0xa0
                              FeeRate makerFee; // 0xc0
                              uint256 salt; // 0xe0
                          }
                          /*
                          Reference only; struct is composed manually using calldata formatting in execution
                          struct ExecutionBatch { // Size: 0x80
                              address taker; // 0x00
                              OrderType orderType; // 0x20
                              Transfer[] transfers; // 0x40
                              uint256 length; // 0x60
                          }
                          */
                          struct Transfer { // Size: 0xa0
                              address trader; // 0x00
                              uint256 id; // 0x20
                              uint256 amount; // 0x40
                              address collection; // 0x60
                              AssetType assetType; // 0x80
                          }
                          struct FungibleTransfers {
                              uint256 totalProtocolFee;
                              uint256 totalSellerTransfer;
                              uint256 totalTakerFee;
                              uint256 feeRecipientId;
                              uint256 makerId;
                              address[] feeRecipients;
                              address[] makers;
                              uint256[] makerTransfers;
                              uint256[] feeTransfers;
                              AtomicExecution[] executions;
                          }
                          struct AtomicExecution { // Size: 0xe0
                              uint256 makerId; // 0x00
                              uint256 sellerAmount; // 0x20
                              uint256 makerFeeRecipientId; // 0x40
                              uint256 makerFeeAmount; // 0x60
                              uint256 takerFeeAmount; // 0x80
                              uint256 protocolFeeAmount; // 0xa0
                              StateUpdate stateUpdate; // 0xc0
                          }
                          struct StateUpdate { // Size: 0xa0
                              address trader; // 0x00
                              bytes32 hash; // 0x20
                              uint256 index; // 0x40
                              uint256 value; // 0x60
                              uint256 maxAmount; // 0x80
                          }
                          struct Fees { // Size: 0x40
                              FeeRate protocolFee; // 0x00
                              FeeRate takerFee; // 0x20
                          }
                          struct FeeRate { // Size: 0x40
                              address recipient; // 0x00
                              uint16 rate; // 0x20
                          }
                          struct Cancel {
                              bytes32 hash;
                              uint256 index;
                              uint256 amount;
                          }