Token

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.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 (last updated v4.9.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 (last updated v4.9.0) (token/ERC1155/IERC1155.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

/**
 * @dev Required interface of an ERC1155 compliant contract, as defined in the
 * https://eips.ethereum.org/EIPS/eip-1155[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155 is IERC165 {
    /**
     * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
     */
    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);

    /**
     * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
     * transfers.
     */
    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] ids,
        uint256[] values
    );

    /**
     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
     * `approved`.
     */
    event ApprovalForAll(address indexed account, address indexed operator, bool approved);

    /**
     * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
     *
     * If an {URI} event was emitted for `id`, the standard
     * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
     * returned by {IERC1155MetadataURI-uri}.
     */
    event URI(string value, uint256 indexed id);

    /**
     * @dev Returns the amount of tokens of token type `id` owned by `account`.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) external view returns (uint256);

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(
        address[] calldata accounts,
        uint256[] calldata ids
    ) external view returns (uint256[] memory);

    /**
     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the caller.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
     *
     * See {setApprovalForAll}.
     */
    function isApprovedForAll(address account, address operator) external view returns (bool);

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

/**
 * @dev _Available since v3.1._
 */
interface IERC1155Receiver is IERC165 {
    /**
     * @dev Handles the receipt of a single ERC1155 token type. This function is
     * called at the end of a `safeTransferFrom` after the balance has been updated.
     *
     * NOTE: To accept the transfer, this must return
     * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
     * (i.e. 0xf23a6e61, or its own function selector).
     *
     * @param operator The address which initiated the transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param id The ID of the token being transferred
     * @param value The amount of tokens being transferred
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
     */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    /**
     * @dev Handles the receipt of a multiple ERC1155 token types. This function
     * is called at the end of a `safeBatchTransferFrom` after the balances have
     * been updated.
     *
     * NOTE: To accept the transfer(s), this must return
     * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
     * (i.e. 0xbc197c81, or its own function selector).
     *
     * @param operator The address which initiated the batch transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param ids An array containing ids of each token being transferred (order and length must match values array)
     * @param values An array containing amounts of each token being transferred (order and length must match ids array)
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
     */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/utils/ERC1155Holder.sol)

pragma solidity ^0.8.0;

import "./ERC1155Receiver.sol";

/**
 * Simple implementation of `ERC1155Receiver` that will allow a contract to hold ERC1155 tokens.
 *
 * IMPORTANT: When inheriting this contract, you must include a way to use the received tokens, otherwise they will be
 * stuck.
 *
 * @dev _Available since v3.1._
 */
contract ERC1155Holder is ERC1155Receiver {
    function onERC1155Received(
        address,
        address,
        uint256,
        uint256,
        bytes memory
    ) public virtual override returns (bytes4) {
        return this.onERC1155Received.selector;
    }

    function onERC1155BatchReceived(
        address,
        address,
        uint256[] memory,
        uint256[] memory,
        bytes memory
    ) public virtual override returns (bytes4) {
        return this.onERC1155BatchReceived.selector;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/utils/ERC1155Receiver.sol)

pragma solidity ^0.8.0;

import "../IERC1155Receiver.sol";
import "../../../utils/introspection/ERC165.sol";

/**
 * @dev _Available since v3.1._
 */
abstract contract ERC1155Receiver is ERC165, IERC1155Receiver {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return interfaceId == type(IERC1155Receiver).interfaceId || super.supportsInterface(interfaceId);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.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 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 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 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
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: MIT

pragma solidity >=0.8.0 <0.9.0;

import "solady/src/utils/DynamicBufferLib.sol";
import "solady/src/utils/LibString.sol";
import "solady/src/utils/SafeTransferLib.sol";
import "solady/src/utils/Base64.sol";
import "solady/src/utils/SSTORE2.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
import "solady/src/utils/LibPRNG.sol";
import "solady/src/tokens/ERC721.sol";

import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import {ERC1155Holder, ERC1155Receiver} from "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";

import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {IERC2981, ERC2981} from "@openzeppelin/contracts/token/common/ERC2981.sol";
import {OperatorFilterer} from "closedsea/src/OperatorFilterer.sol";

import "hardhat/console.sol";

interface PunkDataInterface {
    function punkImage(uint16 index) external view returns (bytes memory);
    function punkAttributes(uint16 index) external view returns (string memory);
}

interface BabylonBook {
    function renderAssetSvgRects(uint8 assetIndex) external view returns (string memory);
}

interface EPD {
    enum PunkAttributeType {SEX, HAIR, EYES, BEARD, EARS, LIPS, MOUTH,
                                FACE, EMOTION, NECK, NOSE, CHEEKS, TEETH}
    
    enum PunkAttributeValue {NONE, ALIEN, APE, BANDANA, BEANIE, BIG_BEARD, BIG_SHADES, BLACK_LIPSTICK, BLONDE_BOB, BLONDE_SHORT, BLUE_EYE_SHADOW, BUCK_TEETH, CAP, CAP_FORWARD, CHINSTRAP, CHOKER, CIGARETTE, CLASSIC_SHADES, CLOWN_EYES_BLUE, CLOWN_EYES_GREEN, CLOWN_HAIR_GREEN, CLOWN_NOSE, COWBOY_HAT, CRAZY_HAIR, DARK_HAIR, DO_RAG, EARRING, EYE_MASK, EYE_PATCH, FEDORA, FEMALE, FRONT_BEARD, FRONT_BEARD_DARK, FROWN, FRUMPY_HAIR, GOAT, GOLD_CHAIN, GREEN_EYE_SHADOW, HALF_SHAVED, HANDLEBARS, HEADBAND, HOODIE, HORNED_RIM_GLASSES, HOT_LIPSTICK, KNITTED_CAP, LUXURIOUS_BEARD, MALE, MEDICAL_MASK, MESSY_HAIR, MOHAWK, MOHAWK_DARK, MOHAWK_THIN, MOLE, MUSTACHE, MUTTONCHOPS, NERD_GLASSES, NORMAL_BEARD, NORMAL_BEARD_BLACK, ORANGE_SIDE, PEAK_SPIKE, PIGTAILS, PILOT_HELMET, PINK_WITH_HAT, PIPE, POLICE_CAP, PURPLE_EYE_SHADOW, PURPLE_HAIR, PURPLE_LIPSTICK, RED_MOHAWK, REGULAR_SHADES, ROSY_CHEEKS, SHADOW_BEARD, SHAVED_HEAD, SILVER_CHAIN, SMALL_SHADES, SMILE, SPOTS, STRAIGHT_HAIR, STRAIGHT_HAIR_BLONDE, STRAIGHT_HAIR_DARK, STRINGY_HAIR, TASSLE_HAT, THREE_D_GLASSES, TIARA, TOP_HAT, VAMPIRE_HAIR, VAPE, VR, WELDING_GOGGLES, WILD_BLONDE, WILD_HAIR, WILD_WHITE_HAIR, ZOMBIE}
    
    function attrStringToEnumMapping(string memory) external view returns (PunkAttributeValue);
    function attrEnumToStringMapping(PunkAttributeValue) external view returns (string memory);
    function attrValueToTypeEnumMapping(PunkAttributeValue) external view returns (PunkAttributeType);
}

contract Drunks is Ownable, ERC721, ERC2981, ERC1155Holder, OperatorFilterer {
    error ContractsCannotMint();
    error MustMintAtLeastOneToken();
    error NotEnoughAvailableTokens();
    error NeedExactPayment();
    error MintIsNotActive();
    error ContractSealed();
    error NothingToWithdraw();
    error WrongKeyContract();
    error WrongKeyItem();
    error WrongKeyAmount();
    error NoMoreRemainingKeyMints();
    
    using LibString for *;
    using SafeTransferLib for *;
    using DynamicBufferLib for DynamicBufferLib.DynamicBuffer;
    using LibPRNG for LibPRNG.PRNG;
    
    struct TraitData {
        uint8 id;
        EPD.PunkAttributeType traitType;
        EPD.PunkAttributeValue traitValueEnum;
        bool isFallen;
        int8[2] translate;
        string internalName;
        string externalName;
    }
    
    struct Drunk {
        uint16 id;
        uint8 fallenTraitCount;
        TraitData[] traits;
    }
    
    struct ContractConfig {
        string name;
        string nameSingular;
        string symbol;
        string externalLink;
        string tokenDescription;
        uint costPerToken;
        uint16 maxSupply;
        uint16 remainingSupply;
        uint8 remainingKeyMints;
        bool operatorFilteringEnabled;
        bool isMintActive;
        bool contractSealed;
    }
    
    ContractConfig internal config;
    
    function getConfig() external view returns (ContractConfig memory) {
        return config;
    }
    
    PunkDataInterface public immutable punkDataContract;
    EPD public immutable extendedPunkDataContract;
    BabylonBook public immutable babylonBook;
    IERC1155 public immutable babylonGame;
    
    address internal constant burnAddress = 0x000000000000000000000000000000000000dEaD;
    uint public constant babylonKeyTokenId = 98817275316469254658835613186317234565061035910961234952676070055051228466648;
    
    uint16[626] internal drunkIds = [5093,3443,6145,1,17,24,32,39,40,219,239,257,295,317,348,370,389,415,416,429,461,495,523,546,562,597,621,623,638,643,656,676,686,704,707,716,825,842,885,908,918,920,959,962,986,1000,1049,1100,1118,1133,1154,1171,1193,1211,1260,1266,1303,1338,1359,1380,1425,1429,1447,1481,1483,1507,1560,1578,1585,1605,1636,1641,1643,1655,1702,1703,1728,1748,1762,1770,1793,1794,1795,1796,1839,1851,1871,1912,1919,2032,2097,2126,2157,2163,2167,2192,2208,2242,2261,2307,2308,2314,2319,2344,2362,2377,2379,2387,2421,2424,2441,2466,2469,2471,2494,2548,2571,2587,2589,2632,2636,2639,2644,2648,2657,2672,2691,2693,2715,2718,2727,2763,2767,2795,2894,2951,2961,3011,3016,3017,3032,3039,3084,3090,3117,3130,3136,3152,3169,3172,3174,3177,3182,3184,3197,3230,3250,3283,3288,3292,3305,3313,3330,3362,3365,3393,3400,3406,3411,3415,3438,3439,3444,3460,3463,3538,3555,3558,3569,3596,3625,3643,3677,3689,3700,3758,3760,3766,3810,3814,3822,3852,3871,3889,3929,3967,3974,3978,3982,4002,4005,4024,4047,4050,4068,4074,4141,4142,4143,4192,4239,4280,4288,4289,4298,4311,4322,4352,4370,4371,4387,4411,4415,4450,4457,4488,4494,4505,4528,4529,4556,4558,4572,4574,4632,4640,4651,4667,4669,4676,4694,4697,4707,4715,4730,4735,4736,4746,4749,4774,4781,4785,4798,4805,4807,4842,4847,4863,4920,4923,4976,4998,5003,5047,5066,5072,5098,5101,5113,5120,5125,5131,5149,5176,5205,5229,5233,5238,5261,5263,5276,5327,5377,5401,5410,5423,5433,5456,5460,5465,5466,5477,5491,5492,5529,5548,5604,5614,5643,5655,5657,5659,5683,5716,5728,5732,5733,5736,5774,5804,5805,5863,5877,5914,5925,5935,5956,5962,5984,6051,6056,6058,6060,6061,6063,6066,6081,6101,6106,6112,6140,6188,6203,6229,6279,6289,6291,6303,6354,6392,6420,6427,6438,6447,6463,6475,6494,6529,6539,6540,6552,6586,6602,6632,6633,6652,6655,6657,6661,6673,6682,6704,6711,6717,6721,6724,6726,6784,6795,6898,6943,6953,6976,6992,6996,7031,7042,7051,7080,7087,7115,7130,7134,7166,7185,7190,7198,7201,7224,7242,7253,7270,7273,7277,7297,7298,7314,7331,7332,7335,7345,7368,7401,7410,7420,7424,7425,7431,7435,7440,7442,7477,7484,7496,7510,7539,7549,7550,7564,7571,7578,7579,7588,7591,7600,7602,7660,7667,7671,7688,7692,7711,7716,7738,7740,7763,7765,7770,7771,7772,7784,7787,7835,7862,7889,7890,7892,7917,7918,7920,7925,7926,7944,7947,7953,7956,7977,7988,8000,8019,8026,8036,8079,8086,8101,8105,8107,8120,8136,8141,8152,8171,8174,8176,8179,8191,8213,8231,8244,8262,8263,8301,8312,8320,8337,8346,8362,8369,8373,8385,8389,8390,8393,8413,8430,8445,8447,8448,8463,8482,8499,8507,8546,8551,8561,8567,8571,8594,8608,8609,8615,8622,8624,8634,8658,8667,8677,8685,8700,8715,8748,8750,8756,8772,8781,8786,8801,8803,8809,8812,8830,8840,8867,8875,8884,8889,8891,8908,8918,8925,8926,8935,8940,8946,8998,9008,9016,9022,9036,9038,9046,9050,9056,9080,9083,9084,9089,9090,9097,9110,9113,9130,9145,9156,9162,9166,9168,9192,9242,9259,9279,9283,9289,9300,9314,9316,9330,9336,9355,9357,9362,9374,9375,9385,9412,9415,9418,9422,9436,9437,9516,9547,9565,9569,9573,9591,9600,9612,9628,9637,9648,9653,9659,9667,9668,9688,9709,9734,9760,9767,9774,9804,9807,9811,9813,9816,9827,9912,9936,9952,9959,9960,9972,9984,9992,9996];
    
    bytes internal constant hashedAssetNames = hex'f2832d534c54446e7286885ad519e00a8b72758d32b85d54faa61b214c6dabe4be3849f4a9d6ff4df983dac6f1faa1511907503b08bea978e9bd0b5dd382b4afcfa9eb095ef25649834463fbe584a554ca5c443de39d7c2877d127c44c21cde6553bc39f4024da6ecfe9661143c88a1818e899dc16b9249f7a54ac877e558c0e364f38889c3fb7c60ab7f036d85c589a4de0d5e29aafd325873c711ce6eb02e44fbed4c57fc058ffccc5be2f3136a21adadb49536ba0ccf9382afaadfc84194a1659ce4584bbce09060896a25fcd06c8d604dd721833744e856106d6b019f52894a6195d3292c84a3f13a7f57c3c44575730838ddfb9d6b84c63fcf77f8cbf07fe4c3225b46654de12bd';

    address constant pivAddress = 0xf98537696e2Cf486F8F32604B2Ca2CDa120DBBa8;
    address constant middleAddress = 0x31c388503566D2E0BA335D22792BddF90bC86C82;
    
    mapping(bool => mapping(EPD.PunkAttributeValue => int8[2])) isFemaleToTranslations;
    
    function isHat(uint8 assetId) internal pure returns (bool res) {
        uint8[10] memory hats = [16,22,25,37,38,46,51,60,105,113];
        
        for (uint i; i < hats.length; ++i) {
            if (hats[i] == assetId) {
                res = true;
            }
        }
    }
    
    function isWig(uint8 assetId) internal pure returns (bool res) {
        uint8[4] memory wigs = [58,65,93,101];
        
        for (uint i; i < wigs.length; ++i) {
            if (wigs[i] == assetId) {
                res = true;
            }
        }
    }
    
    function isSmokingDevice(uint8 assetId) internal pure returns (bool res) {
        uint8[6] memory smokingDevices = [19,32,64,95,115,120];

        for (uint i; i < smokingDevices.length; ++i) {
            if (smokingDevices[i] == assetId) {
                res = true;
            }
        }
    }
    
    function isGlasses(uint8 assetId) internal pure returns (bool res) {
        uint8[14] memory glasses = [20,21,31,35,43,62,72,82,84,89,102,119,124,132];
        
        for (uint i; i < glasses.length; ++i) {
            if (glasses[i] == assetId) {
                res = true;
            }
        }
    }
    
    function name() public view virtual override returns (string memory) {
        return config.name;
    }

    function symbol() public view virtual override returns (string memory) {
        return config.symbol;
    }
    
    function maxSupply() external view returns (uint) {
        return config.maxSupply;
    }
    
    function totalSupply() external view returns (uint16) {
        return config.maxSupply - config.remainingSupply;
    }
    
    function remainingSupply() external view returns (uint16) {
        return config.remainingSupply;
    }
    
    function setContractConfig(ContractConfig calldata _config) external onlyOwner unsealed {
        config = _config;
    }
    
    function _internalEthMint(address to, uint _numToMint) internal {
        if (msg.value != totalMintCost(_numToMint)) revert NeedExactPayment();
        if (msg.sender != tx.origin) revert ContractsCannotMint();

        _internalMintWithoutCostCheck(to, _numToMint);
    }
    
    function _internalKeyMint(address to, uint _numToMint) internal {
        _internalMintWithoutCostCheck(to, _numToMint);
    }
    
    function _internalMintWithoutCostCheck(address to, uint _numToMint) internal {
        if (!config.isMintActive) revert MintIsNotActive();
        if (_numToMint == 0) revert MustMintAtLeastOneToken();
        if (config.remainingSupply < _numToMint) revert NotEnoughAvailableTokens();

        uint seed = uint(keccak256(abi.encodePacked(
            block.timestamp, block.difficulty
        )));
        
        LibPRNG.PRNG memory prng = LibPRNG.PRNG(seed);
        
        uint16 updatedRemainingSupply = config.remainingSupply;
        
        for (uint i; i < _numToMint;) {
            uint randomIndex = prng.uniform(updatedRemainingSupply);

            uint16 tokenId = getAvailableTokenAtIndex(randomIndex, updatedRemainingSupply);
            
            _mint(to, tokenId);
            _setExtraData(tokenId, uint96(seed));
            
            --updatedRemainingSupply;
            
            unchecked {++i;}
        }
        
        config.remainingSupply = updatedRemainingSupply;
    }
    
    function getAvailableTokenAtIndex(uint indexToUse, uint16 updatedRemainingSupply)
        internal
        returns (uint16)
    {
        uint16 result = drunkIds[indexToUse];

        uint16 lastIndex = updatedRemainingSupply - 1;
        uint16 lastValInArray = drunkIds[lastIndex];
        
        if (indexToUse != lastIndex) {
            drunkIds[indexToUse] = lastValInArray;
        }
        
        return result;
    }
    
    modifier unsealed() {
        if (config.contractSealed) revert ContractSealed();
        _;
    }
    
    function setTokenDescription(string calldata _tokenDescription) external onlyOwner unsealed {
        config.tokenDescription = _tokenDescription;
    }
    
    function sealContract() external onlyOwner unsealed {
        config.contractSealed = true;
    }
    
    function flipMintState() external onlyOwner {
        config.isMintActive = !config.isMintActive;
    }
    
    function getTwoBytesAtIndex(bytes memory data, uint256 index) internal pure returns (bytes2) {
        return bytes2((uint16(uint8(data[2 * index])) << 8) | uint16(uint8(data[2 * index + 1])));
    }
    
    function assetNameToAssetId(string memory input) public pure returns (uint8 assetId) {
        uint needle = uint(uint16(bytes2(uint16(uint(keccak256(bytes(input)))))));

        uint256 assetCount = hashedAssetNames.length / 2;
        
        for (uint i; i < assetCount;) {
            uint el = uint256(uint16(getTwoBytesAtIndex(hashedAssetNames, i)));
            
            if (el == needle) {
                return uint8(i + 1);
            }
            
            unchecked {++i;}
        }
    }
    
    constructor(ContractConfig memory _config) {
        config = _config;
        
        config.maxSupply = uint16(drunkIds.length);
        config.remainingSupply = config.maxSupply;
        config.contractSealed = false;
        config.remainingKeyMints = 25;
        
        _registerForOperatorFiltering();
        config.operatorFilteringEnabled = true;
        
        _setDefaultRoyalty(address(this), 500);
        
        punkDataContract = PunkDataInterface(
            block.chainid == 5 ?
                0xd61Cb6E357bF34B9280d6cC6F7CCF1E66C2bcf89 :
                0x16F5A35647D6F03D5D3da7b35409D65ba03aF3B2
        );
        extendedPunkDataContract = EPD(
            block.chainid == 5 ?
                0xA253808c5ACf2597294b9d15F16D8B0429D9A96A :
                0xf03e345bB89Dc9cFaf8Fda381a9E4417BFB46e7A
        );
        
        babylonBook = BabylonBook(
            block.chainid == 5 ?
                0x38F8Df421283Fbe39AA8a4F89076447c8741703b :
                0xd6f61833206712c429E03142D71232f57b46f8aC
        );
        
        babylonGame = IERC1155(
            block.chainid == 5 ?
                0x698da032E7F01D8aaB4055EDa446347d590205d2 :
                0xd19D35601C9F4156cc2cFCcA42aE4aE4A44ACF9A
        );
    }
    
    function airdrop(address toAddress, uint numTokens) external payable {
        _internalEthMint(toAddress, numTokens);
    }
    
    function mintPublic(uint numTokens) external payable {
        _internalEthMint(msg.sender, numTokens);
    }
    
    function exists(uint tokenId) external view returns (bool) {
        return _exists(tokenId);
    }
    
    function tokenURI(uint256 id) public view override returns (string memory) {
        if (!_exists(id)) revert TokenDoesNotExist();

        return constructTokenURI(uint16(id));
    }
    
    function constructTokenURI(uint16 tokenId) internal view returns (string memory) {
        bytes memory title = abi.encodePacked(config.nameSingular, " #", tokenId.toString());

        string memory imageSvg = tokenImage(tokenId);

        return
            string(
                abi.encodePacked(
                    "data:application/json;base64,",
                    Base64.encode(
                        bytes(
                            abi.encodePacked(
                                '{',
                                '"name":"', title, '",'
                                '"description":"', config.tokenDescription.escapeJSON(), '",'
                                '"image":"data:image/svg+xml;base64,', Base64.encode(bytes(wrapSVG(imageSvg))),'",'
                                '"external_url":"', config.externalLink, '",'
                                '"attributes": ',
                                    punkAttributesAsJSON(tokenId),
                                '}'
                            )
                        )
                    )
                )
            );
    }
    
    function tokenImage(uint16 tokenId) public view returns (string memory) {
        DynamicBufferLib.DynamicBuffer memory svgBytes;
        
        svgBytes.append(abi.encodePacked(
            '<svg width="1200" height="1200" shape-rendering="crispEdges" xmlns="http://www.w3.org/2000/svg" ',
            'version="1.2" viewBox="0 0 24 24">',
            '<style>g{transform-origin:center}g.rotate{transform:rotate(90deg)}g.rotate rect[fill="#bababa80"], g.rotate rect[fill="#dedede80"] {display:none}',
            'rect{width:1px;height:1px}</style>',
            '<rect x="0" y="0" style="width:24px;height:14px" fill="#766e61"/>',
            '<rect x="0" y="14" style="width:24px;height:10px" fill="#544b3c"/>'
        ));
        
        svgBytes.append('<g>');
        
        Drunk memory drunk = initializeDrunk(tokenId);
        
        for (uint i; i < drunk.traits.length; ++i) {
            TraitData memory trait = drunk.traits[i];
            
            if (trait.id != 0 && !trait.isFallen) {
                svgBytes.append(abi.encodePacked(
                    '<g class="rotate">',
                        babylonBook.renderAssetSvgRects(trait.id),
                    "</g>"
                ));
            }
        }
        
        for (uint i; i < drunk.traits.length; ++i) {
            TraitData memory trait = drunk.traits[i];
            
            if (trait.id != 0 && trait.isFallen) {
                bytes memory coords = abi.encodePacked(
                    intToString(trait.translate[0]), 'px,', intToString(trait.translate[1]), 'px'
                );
                
                bytes memory translateStr = abi.encodePacked('style="transform:translate(', coords,')"');
            
                bytes memory extraRects;
                
                if (trait.id == 22) {
                    extraRects = '<rect x="6" y="7" fill="black"/><rect x="7" y="6" fill="black"/><rect x="8" y="5" fill="black"/><rect x="9" y="5" fill="black"/><rect x="10" y="5" fill="black"/><rect x="11" y="5" fill="black"/><rect x="12" y="5" fill="black"/><rect x="13" y="5" fill="black"/><rect x="14" y="5" fill="black"/><rect x="15" y="6" fill="black"/><rect x="16" y="7" fill="black"/>';
                }
                
                svgBytes.append(abi.encodePacked(
                    '<g ', translateStr,'>',
                        babylonBook.renderAssetSvgRects(trait.id),
                        extraRects,
                    "</g>"
                ));
            }
        }
        
        svgBytes.append('</g></svg>');
        return string(svgBytes.data);
    }
    
    function intToString(int input) internal pure returns (string memory) {
        return input >= 0 ? uint(input).toString() : string.concat("-", uint(-1 * input).toString());
    }
    
    function wrapSVG(string memory svg) internal pure returns (string memory) {
        return string.concat(
                        '<svg width="100%" height="100%" viewBox="0 0 1200 1200" version="1.2" xmlns="http://www.w3.org/2000/svg"><image width="1200" height="1200" href="data:image/svg+xml;base64,',
                        Base64.encode(bytes(svg)),
                        '"></image></svg>'
                );
    }
    
    function withdraw() external {
        require(address(this).balance > 0);
        
        uint total = address(this).balance;
        uint half = total / 2;
        
        middleAddress.safeTransferETH(half);
        pivAddress.safeTransferETH(total - half);
    }
    
    function totalMintCost(uint numTokens) public view returns (uint) {
        return numTokens * config.costPerToken;
    }
    
    function markDrunkAttributesFallen(Drunk memory drunk) internal view returns (Drunk memory) {
        uint seed = uint(keccak256(abi.encodePacked(
            drunk.id, _getExtraData(drunk.id)
        )));
        
        LibPRNG.PRNG memory prng = LibPRNG.PRNG(seed);
        
        bool isFemale = drunk.traits[0].traitValueEnum == EPD.PunkAttributeValue.FEMALE;
        bool hatFallen;
        bool pipeFallen;
        bool mouthFallen;

        for (uint i; i < drunk.traits.length; ++i) {
            EPD.PunkAttributeType attrType = extendedPunkDataContract.attrValueToTypeEnumMapping(
                extendedPunkDataContract.attrStringToEnumMapping(drunk.traits[i].externalName)
            );
            
            uint8 assetId = drunk.traits[i].id;
            
            if (attrType == EPD.PunkAttributeType.HAIR) {
                if (
                    (isHat(assetId) && prng.uniform(100) >= 5) ||
                    (isWig(assetId) && prng.uniform(100) >= 5)
                ) {
                    drunk.traits[i] = setTranslateOfFallenTraits(isFemale, drunk.traits[i]);
                    drunk.fallenTraitCount++;
                    hatFallen = true;
                }
            }
            
            if (
                attrType == EPD.PunkAttributeType.MOUTH &&
                isSmokingDevice(assetId) &&
                prng.uniform(100) >= 5
            ) {
                drunk.traits[i] = setTranslateOfFallenTraits(isFemale, drunk.traits[i]);
                drunk.fallenTraitCount++;
                mouthFallen = true;
                
                if (drunk.traits[i].traitValueEnum == EPD.PunkAttributeValue.PIPE) {
                    pipeFallen = true;
                }
            }
            
            if (
                attrType == EPD.PunkAttributeType.EYES &&
                isGlasses(assetId) &&
                !pipeFallen &&
                prng.uniform(100) >= 5
            ) {
                drunk.traits[i] = setTranslateOfFallenTraits(isFemale, drunk.traits[i]);
                drunk.fallenTraitCount++;
                
                if (hatFallen) {
                    drunk.traits[i].translate[1]++;
                    drunk.traits[i].translate[0]--;
                    
                    if (!mouthFallen) {
                        drunk.traits[i].translate[0] -= 8;
                    }
                }
            }
        }
        
        return drunk;
    }
    
    function setTranslateOfFallenTraits(
        bool isFemale,
        TraitData memory input
    ) internal view returns (TraitData memory) {
        input.isFallen = true;        
        input.translate = isFemaleToTranslations[isFemale][input.traitValueEnum];
        
        return input;
    }
    
    function initializeDrunk(uint16 punkId) internal view returns (Drunk memory) {
        string memory attributes = punkDataContract.punkAttributes(punkId);

        string[] memory attributeArray = attributes.split(", ");
        
        Drunk memory drunk = Drunk({
            id: punkId,
            fallenTraitCount: 0,
            traits: new TraitData[](attributeArray.length)
        });
        
        for (uint i = 0; i < attributeArray.length; i++) {
            string memory untrimmedAttribute = attributeArray[i];
            string memory trimmedAttribute = untrimmedAttribute;
            uint8 assetId;
            
            if (i == 0) {
                trimmedAttribute = untrimmedAttribute.split(' ')[0];
                assetId = assetNameToAssetId(untrimmedAttribute);
            } else {
                string memory firstLetter = attributeArray[0].slice(0, 1);
                firstLetter = firstLetter.eq("F") ? "F" : "M";
                
                assetId = assetNameToAssetId(
                    string(abi.encodePacked(trimmedAttribute, "_", firstLetter))
                );
            }
            
            EPD.PunkAttributeValue attrValue = extendedPunkDataContract.attrStringToEnumMapping(trimmedAttribute);
            EPD.PunkAttributeType attrType = extendedPunkDataContract.attrValueToTypeEnumMapping(attrValue);
            
            TraitData memory td = TraitData({
                id: assetId,
                traitType: attrType,
                traitValueEnum: attrValue,
                internalName: untrimmedAttribute,
                externalName: trimmedAttribute,
                isFallen: false,
                translate: [int8(0), int8(0)]
            });
            
            drunk.traits[i] = td;
        }
        
        return markDrunkAttributesFallen(drunk);
    }
    
    function punkAttributesAsJSON(uint16 punkId) public view returns (string memory) {
        Drunk memory drunk = initializeDrunk(punkId);
        
        DynamicBufferLib.DynamicBuffer memory outputBytes;
        outputBytes.append("[");
        
        for (uint i; i < drunk.traits.length; ++i) {
            TraitData memory td = drunk.traits[i];
            
            if (td.id != 0) {
                outputBytes.append(bytes(punkAttributeAsJSON(td)));
                
                if (i < drunk.traits.length - 1) {
                    outputBytes.append(",");
                }
            }
        }
        
        outputBytes.append(
            abi.encodePacked(',{"trait_type":"Fallen Traits", "value":"', drunk.fallenTraitCount.toString(), '"}')
        );
        
        return string(abi.encodePacked(outputBytes.data, "]"));
    }
    
    function punkAttributeAsJSON(TraitData memory td) internal pure returns (string memory) {
        string memory attributeAsString = td.externalName;
        string memory attributeTypeAsString;
        
        EPD.PunkAttributeType attrType = td.traitType;
        
        if (attrType == EPD.PunkAttributeType.SEX) {
            attributeTypeAsString = "Sex";
        } else if (attrType == EPD.PunkAttributeType.HAIR) {
            attributeTypeAsString = "Hair";
        } else if (attrType == EPD.PunkAttributeType.EYES) {
            attributeTypeAsString = "Eyes";
        } else if (attrType == EPD.PunkAttributeType.BEARD) {
            attributeTypeAsString = "Beard";
        } else if (attrType == EPD.PunkAttributeType.EARS) {
            attributeTypeAsString = "Ears";
        } else if (attrType == EPD.PunkAttributeType.LIPS) {
            attributeTypeAsString = "Lips";
        } else if (attrType == EPD.PunkAttributeType.MOUTH) {
            attributeTypeAsString = "Mouth";
        } else if (attrType == EPD.PunkAttributeType.FACE) {
            attributeTypeAsString = "Face";
        } else if (attrType == EPD.PunkAttributeType.EMOTION) {
            attributeTypeAsString = "Emotion";
        } else if (attrType == EPD.PunkAttributeType.NECK) {
            attributeTypeAsString = "Neck";
        } else if (attrType == EPD.PunkAttributeType.NOSE) {
            attributeTypeAsString = "Nose";
        } else if (attrType == EPD.PunkAttributeType.CHEEKS) {
            attributeTypeAsString = "Cheeks";
        } else if (attrType == EPD.PunkAttributeType.TEETH) {
            attributeTypeAsString = "Teeth";
        }
        
        return string(abi.encodePacked('{"trait_type":"', attributeTypeAsString, '", "value":"', attributeAsString, '"}'));
    }
    
    function setTranslations(
        EPD.PunkAttributeValue[] calldata femaleValues,
        int8[2][] calldata femaleTranslations,
        EPD.PunkAttributeValue[] calldata nonFemaleValues,
        int8[2][] calldata nonFemaleTranslations
    ) external onlyOwner unsealed {
        uint longerLength = femaleValues.length > nonFemaleValues.length ? femaleValues.length : nonFemaleValues.length;
        
        for (uint i; i < longerLength; ) {
            if (i < femaleValues.length) {
                isFemaleToTranslations[true][femaleValues[i]] = femaleTranslations[i];
            }
            
            if (i < nonFemaleValues.length) {
                isFemaleToTranslations[false][nonFemaleValues[i]] = nonFemaleTranslations[i];
            }
            
            unchecked {++i;}
        }
    }
    
    function remainingKeyMints() external view returns (uint) {
        return config.remainingKeyMints;
    }
    
    function onERC1155Received(
        address,
        address from,
        uint256 id,
        uint256 value,
        bytes memory
    ) public override returns (bytes4) {
        if (msg.sender != address(babylonGame)) revert WrongKeyContract();
        if (id != babylonKeyTokenId) revert WrongKeyItem();
        if (value != 1) revert WrongKeyAmount();
        if (config.remainingKeyMints == 0) revert NoMoreRemainingKeyMints();
        
        config.remainingKeyMints -= 1;
        babylonGame.safeTransferFrom(address(this), burnAddress, id, value, "");
        
        _internalKeyMint(from, 1);
        
        return this.onERC1155Received.selector;
    }

    function setApprovalForAll(address operator, bool approved)
        public
        override
        onlyAllowedOperatorApproval(operator)
    {
        super.setApprovalForAll(operator, approved);
    }

    function approve(address operator, uint256 tokenId)
        public
        payable
        override
        onlyAllowedOperatorApproval(operator)
    {
        super.approve(operator, tokenId);
    }

    function transferFrom(address from, address to, uint256 tokenId)
        public
        payable
        override
        onlyAllowedOperator(from)
    {
        super.transferFrom(from, to, tokenId);
    }

    function safeTransferFrom(address from, address to, uint256 tokenId)
        public
        payable
        override
        onlyAllowedOperator(from)
    {
        super.safeTransferFrom(from, to, tokenId);
    }

    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data)
        public
        payable
        override
        onlyAllowedOperator(from)
    {
        super.safeTransferFrom(from, to, tokenId, data);
    }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        virtual
        override(ERC721, ERC2981, ERC1155Receiver)
        returns (bool) {
        return ERC721.supportsInterface(interfaceId) ||
               ERC1155Receiver.supportsInterface(interfaceId) ||
               ERC2981.supportsInterface(interfaceId);
    }

    function setDefaultRoyalty(address receiver, uint96 feeNumerator) external onlyOwner {
        _setDefaultRoyalty(receiver, feeNumerator);
    }

    function setOperatorFilteringEnabled(bool value) external onlyOwner {
        config.operatorFilteringEnabled = value;
    }

    function _operatorFilteringEnabled() internal view override returns (bool) {
        return config.operatorFilteringEnabled;
    }

    function _isPriorityOperator(address operator) internal pure override returns (bool) {
        return operator == address(0x1E0049783F008A0085193E00003D00cd54003c71);
    }
    
    receive() external payable {}
    fallback (bytes calldata) external payable returns (bytes memory) {}
}

// SPDX-License-Identifier: MIT
pragma solidity >= 0.4.22 <0.9.0;

library console {
	address constant CONSOLE_ADDRESS = address(0x000000000000000000636F6e736F6c652e6c6f67);

	function _sendLogPayload(bytes memory payload) private view {
		uint256 payloadLength = payload.length;
		address consoleAddress = CONSOLE_ADDRESS;
		assembly {
			let payloadStart := add(payload, 32)
			let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)
		}
	}

	function log() internal view {
		_sendLogPayload(abi.encodeWithSignature("log()"));
	}

	function logInt(int256 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(int256)", p0));
	}

	function logUint(uint256 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256)", p0));
	}

	function logString(string memory p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
	}

	function logBool(bool p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
	}

	function logAddress(address p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address)", p0));
	}

	function logBytes(bytes memory p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes)", p0));
	}

	function logBytes1(bytes1 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0));
	}

	function logBytes2(bytes2 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0));
	}

	function logBytes3(bytes3 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0));
	}

	function logBytes4(bytes4 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0));
	}

	function logBytes5(bytes5 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0));
	}

	function logBytes6(bytes6 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0));
	}

	function logBytes7(bytes7 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0));
	}

	function logBytes8(bytes8 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0));
	}

	function logBytes9(bytes9 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0));
	}

	function logBytes10(bytes10 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0));
	}

	function logBytes11(bytes11 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0));
	}

	function logBytes12(bytes12 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0));
	}

	function logBytes13(bytes13 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0));
	}

	function logBytes14(bytes14 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0));
	}

	function logBytes15(bytes15 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0));
	}

	function logBytes16(bytes16 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0));
	}

	function logBytes17(bytes17 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0));
	}

	function logBytes18(bytes18 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0));
	}

	function logBytes19(bytes19 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0));
	}

	function logBytes20(bytes20 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0));
	}

	function logBytes21(bytes21 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0));
	}

	function logBytes22(bytes22 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0));
	}

	function logBytes23(bytes23 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0));
	}

	function logBytes24(bytes24 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0));
	}

	function logBytes25(bytes25 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0));
	}

	function logBytes26(bytes26 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0));
	}

	function logBytes27(bytes27 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0));
	}

	function logBytes28(bytes28 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0));
	}

	function logBytes29(bytes29 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0));
	}

	function logBytes30(bytes30 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0));
	}

	function logBytes31(bytes31 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0));
	}

	function logBytes32(bytes32 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0));
	}

	function log(uint256 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256)", p0));
	}

	function log(string memory p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
	}

	function log(bool p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
	}

	function log(address p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address)", p0));
	}

	function log(uint256 p0, uint256 p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256)", p0, p1));
	}

	function log(uint256 p0, string memory p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string)", p0, p1));
	}

	function log(uint256 p0, bool p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool)", p0, p1));
	}

	function log(uint256 p0, address p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address)", p0, p1));
	}

	function log(string memory p0, uint256 p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256)", p0, p1));
	}

	function log(string memory p0, string memory p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
	}

	function log(string memory p0, bool p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1));
	}

	function log(string memory p0, address p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1));
	}

	function log(bool p0, uint256 p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256)", p0, p1));
	}

	function log(bool p0, string memory p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1));
	}

	function log(bool p0, bool p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1));
	}

	function log(bool p0, address p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1));
	}

	function log(address p0, uint256 p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256)", p0, p1));
	}

	function log(address p0, string memory p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1));
	}

	function log(address p0, bool p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1));
	}

	function log(address p0, address p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1));
	}

	function log(uint256 p0, uint256 p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256)", p0, p1, p2));
	}

	function log(uint256 p0, uint256 p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string)", p0, p1, p2));
	}

	function log(uint256 p0, uint256 p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool)", p0, p1, p2));
	}

	function log(uint256 p0, uint256 p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address)", p0, p1, p2));
	}

	function log(uint256 p0, string memory p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256)", p0, p1, p2));
	}

	function log(uint256 p0, string memory p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,string)", p0, p1, p2));
	}

	function log(uint256 p0, string memory p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool)", p0, p1, p2));
	}

	function log(uint256 p0, string memory p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,address)", p0, p1, p2));
	}

	function log(uint256 p0, bool p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256)", p0, p1, p2));
	}

	function log(uint256 p0, bool p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string)", p0, p1, p2));
	}

	function log(uint256 p0, bool p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool)", p0, p1, p2));
	}

	function log(uint256 p0, bool p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address)", p0, p1, p2));
	}

	function log(uint256 p0, address p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256)", p0, p1, p2));
	}

	function log(uint256 p0, address p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,string)", p0, p1, p2));
	}

	function log(uint256 p0, address p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool)", p0, p1, p2));
	}

	function log(uint256 p0, address p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,address)", p0, p1, p2));
	}

	function log(string memory p0, uint256 p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256)", p0, p1, p2));
	}

	function log(string memory p0, uint256 p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,string)", p0, p1, p2));
	}

	function log(string memory p0, uint256 p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool)", p0, p1, p2));
	}

	function log(string memory p0, uint256 p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,address)", p0, p1, p2));
	}

	function log(string memory p0, string memory p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint256)", p0, p1, p2));
	}

	function log(string memory p0, string memory p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2));
	}

	function log(string memory p0, string memory p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2));
	}

	function log(string memory p0, string memory p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2));
	}

	function log(string memory p0, bool p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256)", p0, p1, p2));
	}

	function log(string memory p0, bool p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2));
	}

	function log(string memory p0, bool p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2));
	}

	function log(string memory p0, bool p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2));
	}

	function log(string memory p0, address p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint256)", p0, p1, p2));
	}

	function log(string memory p0, address p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2));
	}

	function log(string memory p0, address p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2));
	}

	function log(string memory p0, address p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2));
	}

	function log(bool p0, uint256 p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256)", p0, p1, p2));
	}

	function log(bool p0, uint256 p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string)", p0, p1, p2));
	}

	function log(bool p0, uint256 p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool)", p0, p1, p2));
	}

	function log(bool p0, uint256 p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address)", p0, p1, p2));
	}

	function log(bool p0, string memory p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256)", p0, p1, p2));
	}

	function log(bool p0, string memory p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2));
	}

	function log(bool p0, string memory p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2));
	}

	function log(bool p0, string memory p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2));
	}

	function log(bool p0, bool p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256)", p0, p1, p2));
	}

	function log(bool p0, bool p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2));
	}

	function log(bool p0, bool p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2));
	}

	function log(bool p0, bool p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2));
	}

	function log(bool p0, address p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256)", p0, p1, p2));
	}

	function log(bool p0, address p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2));
	}

	function log(bool p0, address p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2));
	}

	function log(bool p0, address p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2));
	}

	function log(address p0, uint256 p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256)", p0, p1, p2));
	}

	function log(address p0, uint256 p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,string)", p0, p1, p2));
	}

	function log(address p0, uint256 p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool)", p0, p1, p2));
	}

	function log(address p0, uint256 p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,address)", p0, p1, p2));
	}

	function log(address p0, string memory p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint256)", p0, p1, p2));
	}

	function log(address p0, string memory p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2));
	}

	function log(address p0, string memory p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2));
	}

	function log(address p0, string memory p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2));
	}

	function log(address p0, bool p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256)", p0, p1, p2));
	}

	function log(address p0, bool p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2));
	}

	function log(address p0, bool p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2));
	}

	function log(address p0, bool p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2));
	}

	function log(address p0, address p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint256)", p0, p1, p2));
	}

	function log(address p0, address p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2));
	}

	function log(address p0, address p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2));
	}

	function log(address p0, address p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2));
	}

	function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,string)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,address)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,string)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,address)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,string)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,address)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,string)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,address)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,string)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,address)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,string)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,address)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,string)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,address)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,string)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,bool)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,address)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,string)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,bool)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,address)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,string)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,bool)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,address)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,string)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,bool)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,address)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,string)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,bool)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,address)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,string)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,bool)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,address)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,string)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,bool)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,address)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3));
	}

}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

/// @notice Simple ERC721 implementation with storage hitchhiking.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/tokens/ERC721.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC721.sol)
/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC721/ERC721.sol)
abstract contract ERC721 {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         CONSTANTS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev An account can hold up to 4294967295 tokens.
    uint256 internal constant _MAX_ACCOUNT_BALANCE = 0xffffffff;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Only the token owner or an approved account can manage the token.
    error NotOwnerNorApproved();

    /// @dev The token does not exist.
    error TokenDoesNotExist();

    /// @dev The token already exists.
    error TokenAlreadyExists();

    /// @dev Cannot query the balance for the zero address.
    error BalanceQueryForZeroAddress();

    /// @dev Cannot mint or transfer to the zero address.
    error TransferToZeroAddress();

    /// @dev The token must be owned by `from`.
    error TransferFromIncorrectOwner();

    /// @dev The recipient's balance has overflowed.
    error AccountBalanceOverflow();

    /// @dev Cannot safely transfer to a contract that does not implement
    /// the ERC721Receiver interface.
    error TransferToNonERC721ReceiverImplementer();

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                           EVENTS                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Emitted when token `id` is transferred from `from` to `to`.
    event Transfer(address indexed from, address indexed to, uint256 indexed id);

    /// @dev Emitted when `owner` enables `account` to manage the `id` token.
    event Approval(address indexed owner, address indexed account, uint256 indexed id);

    /// @dev Emitted when `owner` enables or disables `operator` to manage all of their tokens.
    event ApprovalForAll(address indexed owner, address indexed operator, bool isApproved);

    /// @dev `keccak256(bytes("Transfer(address,address,uint256)"))`.
    uint256 private constant _TRANSFER_EVENT_SIGNATURE =
        0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;

    /// @dev `keccak256(bytes("Approval(address,address,uint256)"))`.
    uint256 private constant _APPROVAL_EVENT_SIGNATURE =
        0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925;

    /// @dev `keccak256(bytes("ApprovalForAll(address,address,bool)"))`.
    uint256 private constant _APPROVAL_FOR_ALL_EVENT_SIGNATURE =
        0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          STORAGE                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The ownership data slot of `id` is given by:
    /// ```
    ///     mstore(0x00, id)
    ///     mstore(0x1c, _ERC721_MASTER_SLOT_SEED)
    ///     let ownershipSlot := add(id, add(id, keccak256(0x00, 0x20)))
    /// ```
    /// Bits Layout:
    // - [0..159]   `addr`
    // - [160..223] `extraData`
    ///
    /// The approved address slot is given by: `add(1, ownershipSlot)`.
    ///
    /// See: https://notes.ethereum.org/%40vbuterin/verkle_tree_eip
    ///
    /// The balance slot of `owner` is given by:
    /// ```
    ///     mstore(0x1c, _ERC721_MASTER_SLOT_SEED)
    ///     mstore(0x00, owner)
    ///     let balanceSlot := keccak256(0x0c, 0x1c)
    /// ```
    /// Bits Layout:
    /// - [0..31]   `balance`
    /// - [32..225] `aux`
    ///
    /// The `operator` approval slot of `owner` is given by:
    /// ```
    ///     mstore(0x1c, or(_ERC721_MASTER_SLOT_SEED, operator))
    ///     mstore(0x00, owner)
    ///     let operatorApprovalSlot := keccak256(0x0c, 0x30)
    /// ```
    uint256 private constant _ERC721_MASTER_SLOT_SEED = 0x7d8825530a5a2e7a << 192;

    /// @dev Pre-shifted and pre-masked constant.
    uint256 private constant _ERC721_MASTER_SLOT_SEED_MASKED = 0x0a5a2e7a00000000;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                      ERC721 METADATA                       */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the token collection name.
    function name() public view virtual returns (string memory);

    /// @dev Returns the token collection symbol.
    function symbol() public view virtual returns (string memory);

    /// @dev Returns the Uniform Resource Identifier (URI) for token `id`.
    function tokenURI(uint256 id) public view virtual returns (string memory);

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                           ERC721                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the owner of token `id`.
    ///
    /// Requirements:
    /// - Token `id` must exist.
    function ownerOf(uint256 id) public view virtual returns (address result) {
        result = _ownerOf(id);
        /// @solidity memory-safe-assembly
        assembly {
            if iszero(result) {
                mstore(0x00, 0xceea21b6) // `TokenDoesNotExist()`.
                revert(0x1c, 0x04)
            }
        }
    }

    /// @dev Returns the number of tokens owned by `owner`.
    ///
    /// Requirements:
    /// - `owner` must not be the zero address.
    function balanceOf(address owner) public view virtual returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            // Revert if the `owner` is the zero address.
            if iszero(owner) {
                mstore(0x00, 0x8f4eb604) // `BalanceQueryForZeroAddress()`.
                revert(0x1c, 0x04)
            }
            mstore(0x1c, _ERC721_MASTER_SLOT_SEED)
            mstore(0x00, owner)
            result := and(sload(keccak256(0x0c, 0x1c)), _MAX_ACCOUNT_BALANCE)
        }
    }

    /// @dev Returns the account approved to managed token `id`.
    ///
    /// Requirements:
    /// - Token `id` must exist.
    function getApproved(uint256 id) public view virtual returns (address result) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, id)
            mstore(0x1c, _ERC721_MASTER_SLOT_SEED)
            let ownershipSlot := add(id, add(id, keccak256(0x00, 0x20)))
            if iszero(shr(96, shl(96, sload(ownershipSlot)))) {
                mstore(0x00, 0xceea21b6) // `TokenDoesNotExist()`.
                revert(0x1c, 0x04)
            }
            result := sload(add(1, ownershipSlot))
        }
    }

    /// @dev Sets `account` as the approved account to manage token `id`.
    ///
    /// Requirements:
    /// - Token `id` must exist.
    /// - The caller must be the owner of the token,
    ///   or an approved operator for the token owner.
    ///
    /// Emits a {Approval} event.
    function approve(address account, uint256 id) public payable virtual {
        _approve(msg.sender, account, id);
    }

    /// @dev Returns whether `operator` is approved to manage the tokens of `owner`.
    function isApprovedForAll(address owner, address operator)
        public
        view
        virtual
        returns (bool result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x1c, operator)
            mstore(0x08, _ERC721_MASTER_SLOT_SEED_MASKED)
            mstore(0x00, owner)
            result := sload(keccak256(0x0c, 0x30))
        }
    }

    /// @dev Sets whether `operator` is approved to manage the tokens of the caller.
    ///
    /// Emits a {ApprovalForAll} event.
    function setApprovalForAll(address operator, bool isApproved) public virtual {
        /// @solidity memory-safe-assembly
        assembly {
            // Convert to 0 or 1.
            isApproved := iszero(iszero(isApproved))
            // Update the `isApproved` for (`msg.sender`, `operator`).
            mstore(0x1c, operator)
            mstore(0x08, _ERC721_MASTER_SLOT_SEED_MASKED)
            mstore(0x00, caller())
            sstore(keccak256(0x0c, 0x30), isApproved)
            // Emit the {ApprovalForAll} event.
            mstore(0x00, isApproved)
            log3(
                0x00, 0x20, _APPROVAL_FOR_ALL_EVENT_SIGNATURE, caller(), shr(96, shl(96, operator))
            )
        }
    }

    /// @dev Transfers token `id` from `from` to `to`.
    ///
    /// Requirements:
    ///
    /// - Token `id` must exist.
    /// - `from` must be the owner of the token.
    /// - `to` cannot be the zero address.
    /// - The caller must be the owner of the token, or be approved to manage the token.
    ///
    /// Emits a {Transfer} event.
    function transferFrom(address from, address to, uint256 id) public payable virtual {
        _beforeTokenTransfer(from, to, id);
        /// @solidity memory-safe-assembly
        assembly {
            // Clear the upper 96 bits.
            let bitmaskAddress := shr(96, not(0))
            from := and(bitmaskAddress, from)
            to := and(bitmaskAddress, to)
            // Load the ownership data.
            mstore(0x00, id)
            mstore(0x1c, or(_ERC721_MASTER_SLOT_SEED, caller()))
            let ownershipSlot := add(id, add(id, keccak256(0x00, 0x20)))
            let ownershipPacked := sload(ownershipSlot)
            let owner := and(bitmaskAddress, ownershipPacked)
            // Revert if `from` is not the owner, or does not exist.
            if iszero(mul(owner, eq(owner, from))) {
                if iszero(owner) {
                    mstore(0x00, 0xceea21b6) // `TokenDoesNotExist()`.
                    revert(0x1c, 0x04)
                }
                mstore(0x00, 0xa1148100) // `TransferFromIncorrectOwner()`.
                revert(0x1c, 0x04)
            }
            // Revert if `to` is the zero address.
            if iszero(to) {
                mstore(0x00, 0xea553b34) // `TransferToZeroAddress()`.
                revert(0x1c, 0x04)
            }
            // Load, check, and update the token approval.
            {
                mstore(0x00, from)
                let approvedAddress := sload(add(1, ownershipSlot))
                // Revert if the caller is not the owner, nor approved.
                if iszero(or(eq(caller(), from), eq(caller(), approvedAddress))) {
                    if iszero(sload(keccak256(0x0c, 0x30))) {
                        mstore(0x00, 0x4b6e7f18) // `NotOwnerNorApproved()`.
                        revert(0x1c, 0x04)
                    }
                }
                // Delete the approved address if any.
                if approvedAddress { sstore(add(1, ownershipSlot), 0) }
            }
            // Update with the new owner.
            sstore(ownershipSlot, xor(ownershipPacked, xor(from, to)))
            // Decrement the balance of `from`.
            {
                let fromBalanceSlot := keccak256(0x0c, 0x1c)
                sstore(fromBalanceSlot, sub(sload(fromBalanceSlot), 1))
            }
            // Increment the balance of `to`.
            {
                mstore(0x00, to)
                let toBalanceSlot := keccak256(0x0c, 0x1c)
                let toBalanceSlotPacked := add(sload(toBalanceSlot), 1)
                if iszero(and(toBalanceSlotPacked, _MAX_ACCOUNT_BALANCE)) {
                    mstore(0x00, 0x01336cea) // `AccountBalanceOverflow()`.
                    revert(0x1c, 0x04)
                }
                sstore(toBalanceSlot, toBalanceSlotPacked)
            }
            // Emit the {Transfer} event.
            log4(0x00, 0x00, _TRANSFER_EVENT_SIGNATURE, from, to, id)
        }
        _afterTokenTransfer(from, to, id);
    }

    /// @dev Equivalent to `safeTransferFrom(from, to, id, "")`.
    function safeTransferFrom(address from, address to, uint256 id) public payable virtual {
        transferFrom(from, to, id);
        if (_hasCode(to)) _checkOnERC721Received(from, to, id, "");
    }

    /// @dev Transfers token `id` from `from` to `to`.
    ///
    /// Requirements:
    ///
    /// - Token `id` must exist.
    /// - `from` must be the owner of the token.
    /// - `to` cannot be the zero address.
    /// - The caller must be the owner of the token, or be approved to manage the token.
    /// - 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 id, bytes calldata data)
        public
        payable
        virtual
    {
        transferFrom(from, to, id);
        if (_hasCode(to)) _checkOnERC721Received(from, to, id, data);
    }

    /// @dev Returns true if this contract implements the interface defined by `interfaceId`.
    /// See: https://eips.ethereum.org/EIPS/eip-165
    /// This function call must use less than 30000 gas.
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            let s := shr(224, interfaceId)
            // ERC165: 0x01ffc9a7, ERC721: 0x80ac58cd, ERC721Metadata: 0x5b5e139f.
            result := or(or(eq(s, 0x01ffc9a7), eq(s, 0x80ac58cd)), eq(s, 0x5b5e139f))
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                  INTERNAL QUERY FUNCTIONS                  */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns if token `id` exists.
    function _exists(uint256 id) internal view virtual returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, id)
            mstore(0x1c, _ERC721_MASTER_SLOT_SEED)
            result := shl(96, sload(add(id, add(id, keccak256(0x00, 0x20)))))
        }
    }

    /// @dev Returns the owner of token `id`.
    /// Returns the zero address instead of reverting if the token does not exist.
    function _ownerOf(uint256 id) internal view virtual returns (address result) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, id)
            mstore(0x1c, _ERC721_MASTER_SLOT_SEED)
            result := shr(96, shl(96, sload(add(id, add(id, keccak256(0x00, 0x20))))))
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*            INTERNAL DATA HITCHHIKING FUNCTIONS             */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the auxiliary data for `owner`.
    /// Minting, transferring, burning the tokens of `owner` will not change the auxiliary data.
    /// Auxiliary data can be set for any address, even if it does not have any tokens.
    function _getAux(address owner) internal view virtual returns (uint224 result) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x1c, _ERC721_MASTER_SLOT_SEED)
            mstore(0x00, owner)
            result := shr(32, sload(keccak256(0x0c, 0x1c)))
        }
    }

    /// @dev Set the auxiliary data for `owner` to `value`.
    /// Minting, transferring, burning the tokens of `owner` will not change the auxiliary data.
    /// Auxiliary data can be set for any address, even if it does not have any tokens.
    function _setAux(address owner, uint224 value) internal virtual {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x1c, _ERC721_MASTER_SLOT_SEED)
            mstore(0x00, owner)
            let balanceSlot := keccak256(0x0c, 0x1c)
            let packed := sload(balanceSlot)
            sstore(balanceSlot, xor(packed, shl(32, xor(value, shr(32, packed)))))
        }
    }

    /// @dev Returns the extra data for token `id`.
    /// Minting, transferring, burning a token will not change the extra data.
    /// The extra data can be set on a non existent token.
    function _getExtraData(uint256 id) internal view virtual returns (uint96 result) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, id)
            mstore(0x1c, _ERC721_MASTER_SLOT_SEED)
            result := shr(160, sload(add(id, add(id, keccak256(0x00, 0x20)))))
        }
    }

    /// @dev Sets the extra data for token `id` to `value`.
    /// Minting, transferring, burning a token will not change the extra data.
    /// The extra data can be set on a non existent token.
    function _setExtraData(uint256 id, uint96 value) internal virtual {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, id)
            mstore(0x1c, _ERC721_MASTER_SLOT_SEED)
            let ownershipSlot := add(id, add(id, keccak256(0x00, 0x20)))
            let packed := sload(ownershipSlot)
            sstore(ownershipSlot, xor(packed, shl(160, xor(value, shr(160, packed)))))
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                  INTERNAL MINT FUNCTIONS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Mints token `id` to `to`.
    ///
    /// Requirements:
    ///
    /// - Token `id` must not exist.
    /// - `to` cannot be the zero address.
    ///
    /// Emits a {Transfer} event.
    function _mint(address to, uint256 id) internal virtual {
        _beforeTokenTransfer(address(0), to, id);
        /// @solidity memory-safe-assembly
        assembly {
            // Clear the upper 96 bits.
            to := shr(96, shl(96, to))
            // Revert if `to` is the zero address.
            if iszero(to) {
                mstore(0x00, 0xea553b34) // `TransferToZeroAddress()`.
                revert(0x1c, 0x04)
            }
            // Load the ownership data.
            mstore(0x00, id)
            mstore(0x1c, _ERC721_MASTER_SLOT_SEED)
            let ownershipSlot := add(id, add(id, keccak256(0x00, 0x20)))
            let ownershipPacked := sload(ownershipSlot)
            // Revert if the token already exists.
            if shl(96, ownershipPacked) {
                mstore(0x00, 0xc991cbb1) // `TokenAlreadyExists()`.
                revert(0x1c, 0x04)
            }
            // Update with the owner.
            sstore(ownershipSlot, or(ownershipPacked, to))
            // Increment the balance of the owner.
            {
                mstore(0x00, to)
                let balanceSlot := keccak256(0x0c, 0x1c)
                let balanceSlotPacked := add(sload(balanceSlot), 1)
                if iszero(and(balanceSlotPacked, _MAX_ACCOUNT_BALANCE)) {
                    mstore(0x00, 0x01336cea) // `AccountBalanceOverflow()`.
                    revert(0x1c, 0x04)
                }
                sstore(balanceSlot, balanceSlotPacked)
            }
            // Emit the {Transfer} event.
            log4(0x00, 0x00, _TRANSFER_EVENT_SIGNATURE, 0, to, id)
        }
        _afterTokenTransfer(address(0), to, id);
    }

    /// @dev Equivalent to `_safeMint(to, id, "")`.
    function _safeMint(address to, uint256 id) internal virtual {
        _safeMint(to, id, "");
    }

    /// @dev Mints token `id` to `to`.
    ///
    /// Requirements:
    ///
    /// - Token `id` must not exist.
    /// - `to` cannot be the zero address.
    /// - If `to` refers to a smart contract, it must implement
    ///   {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
    ///
    /// Emits a {Transfer} event.
    function _safeMint(address to, uint256 id, bytes memory data) internal virtual {
        _mint(to, id);
        if (_hasCode(to)) _checkOnERC721Received(address(0), to, id, data);
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                  INTERNAL BURN FUNCTIONS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Equivalent to `_burn(address(0), id)`.
    function _burn(uint256 id) internal virtual {
        _burn(address(0), id);
    }

    /// @dev Destroys token `id`, using `by`.
    ///
    /// Requirements:
    ///
    /// - Token `id` must exist.
    /// - If `by` is not the zero address,
    ///   it must be the owner of the token, or be approved to manage the token.
    ///
    /// Emits a {Transfer} event.
    function _burn(address by, uint256 id) internal virtual {
        address owner = ownerOf(id);
        _beforeTokenTransfer(owner, address(0), id);
        /// @solidity memory-safe-assembly
        assembly {
            // Clear the upper 96 bits.
            by := shr(96, shl(96, by))
            // Load the ownership data.
            mstore(0x00, id)
            mstore(0x1c, or(_ERC721_MASTER_SLOT_SEED, by))
            let ownershipSlot := add(id, add(id, keccak256(0x00, 0x20)))
            let ownershipPacked := sload(ownershipSlot)
            // Reload the owner in case it is changed in `_beforeTokenTransfer`.
            owner := shr(96, shl(96, ownershipPacked))
            // Revert if the token does not exist.
            if iszero(owner) {
                mstore(0x00, 0xceea21b6) // `TokenDoesNotExist()`.
                revert(0x1c, 0x04)
            }
            // Load and check the token approval.
            {
                mstore(0x00, owner)
                let approvedAddress := sload(add(1, ownershipSlot))
                // If `by` is not the zero address, do the authorization check.
                // Revert if the `by` is not the owner, nor approved.
                if iszero(or(iszero(by), or(eq(by, owner), eq(by, approvedAddress)))) {
                    if iszero(sload(keccak256(0x0c, 0x30))) {
                        mstore(0x00, 0x4b6e7f18) // `NotOwnerNorApproved()`.
                        revert(0x1c, 0x04)
                    }
                }
                // Delete the approved address if any.
                if approvedAddress { sstore(add(1, ownershipSlot), 0) }
            }
            // Clear the owner.
            sstore(ownershipSlot, xor(ownershipPacked, owner))
            // Decrement the balance of `owner`.
            {
                let balanceSlot := keccak256(0x0c, 0x1c)
                sstore(balanceSlot, sub(sload(balanceSlot), 1))
            }
            // Emit the {Transfer} event.
            log4(0x00, 0x00, _TRANSFER_EVENT_SIGNATURE, owner, 0, id)
        }
        _afterTokenTransfer(owner, address(0), id);
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                INTERNAL APPROVAL FUNCTIONS                 */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns whether `account` is the owner of token `id`, or is approved to managed it.
    ///
    /// Requirements:
    /// - Token `id` must exist.
    function _isApprovedOrOwner(address account, uint256 id)
        internal
        view
        virtual
        returns (bool result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            result := 1
            // Clear the upper 96 bits.
            account := shr(96, shl(96, account))
            // Load the ownership data.
            mstore(0x00, id)
            mstore(0x1c, or(_ERC721_MASTER_SLOT_SEED, account))
            let ownershipSlot := add(id, add(id, keccak256(0x00, 0x20)))
            let owner := shr(96, shl(96, sload(ownershipSlot)))
            // Revert if the token does not exist.
            if iszero(owner) {
                mstore(0x00, 0xceea21b6) // `TokenDoesNotExist()`.
                revert(0x1c, 0x04)
            }
            // Check if `account` is the `owner`.
            if iszero(eq(account, owner)) {
                mstore(0x00, owner)
                // Check if `account` is approved to
                if iszero(sload(keccak256(0x0c, 0x30))) {
                    result := eq(account, sload(add(1, ownershipSlot)))
                }
            }
        }
    }

    /// @dev Returns the account approved to manage token `id`.
    /// Returns the zero address instead of reverting if the token does not exist.
    function _getApproved(uint256 id) internal view virtual returns (address result) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, id)
            mstore(0x1c, _ERC721_MASTER_SLOT_SEED)
            result := sload(add(1, add(id, add(id, keccak256(0x00, 0x20)))))
        }
    }

    /// @dev Equivalent to `_approve(address(0), account, id)`.
    function _approve(address account, uint256 id) internal virtual {
        _approve(address(0), account, id);
    }

    /// @dev Sets `account` as the approved account to manage token `id`, using `by`.
    ///
    /// Requirements:
    /// - Token `id` must exist.
    /// - If `by` is not the zero address, `by` must be the owner
    ///   or an approved operator for the token owner.
    ///
    /// Emits a {Transfer} event.
    function _approve(address by, address account, uint256 id) internal virtual {
        assembly {
            // Clear the upper 96 bits.
            let bitmaskAddress := shr(96, not(0))
            account := and(bitmaskAddress, account)
            by := and(bitmaskAddress, by)
            // Load the owner of the token.
            mstore(0x00, id)
            mstore(0x1c, or(_ERC721_MASTER_SLOT_SEED, by))
            let ownershipSlot := add(id, add(id, keccak256(0x00, 0x20)))
            let owner := and(bitmaskAddress, sload(ownershipSlot))
            // Revert if the token does not exist.
            if iszero(owner) {
                mstore(0x00, 0xceea21b6) // `TokenDoesNotExist()`.
                revert(0x1c, 0x04)
            }
            // If `by` is not the zero address, do the authorization check.
            // Revert if `by` is not the owner, nor approved.
            if iszero(or(iszero(by), eq(by, owner))) {
                mstore(0x00, owner)
                if iszero(sload(keccak256(0x0c, 0x30))) {
                    mstore(0x00, 0x4b6e7f18) // `NotOwnerNorApproved()`.
                    revert(0x1c, 0x04)
                }
            }
            // Sets `account` as the approved account to manage `id`.
            sstore(add(1, ownershipSlot), account)
            // Emit the {Approval} event.
            log4(0x00, 0x00, _APPROVAL_EVENT_SIGNATURE, owner, account, id)
        }
    }

    /// @dev Approve or remove the `operator` as an operator for `by`,
    /// without authorization checks.
    ///
    /// Emits a {ApprovalForAll} event.
    function _setApprovalForAll(address by, address operator, bool isApproved) internal virtual {
        /// @solidity memory-safe-assembly
        assembly {
            // Clear the upper 96 bits.
            by := shr(96, shl(96, by))
            operator := shr(96, shl(96, operator))
            // Convert to 0 or 1.
            isApproved := iszero(iszero(isApproved))
            // Update the `isApproved` for (`by`, `operator`).
            mstore(0x1c, or(_ERC721_MASTER_SLOT_SEED, operator))
            mstore(0x00, by)
            sstore(keccak256(0x0c, 0x30), isApproved)
            // Emit the {ApprovalForAll} event.
            mstore(0x00, isApproved)
            log3(0x00, 0x20, _APPROVAL_FOR_ALL_EVENT_SIGNATURE, by, operator)
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                INTERNAL TRANSFER FUNCTIONS                 */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Equivalent to `_transfer(address(0), from, to, id)`.
    function _transfer(address from, address to, uint256 id) internal virtual {
        _transfer(address(0), from, to, id);
    }

    /// @dev Transfers token `id` from `from` to `to`.
    ///
    /// Requirements:
    ///
    /// - Token `id` must exist.
    /// - `from` must be the owner of the token.
    /// - `to` cannot be the zero address.
    /// - If `by` is not the zero address,
    ///   it must be the owner of the token, or be approved to manage the token.
    ///
    /// Emits a {Transfer} event.
    function _transfer(address by, address from, address to, uint256 id) internal virtual {
        _beforeTokenTransfer(from, to, id);
        /// @solidity memory-safe-assembly
        assembly {
            // Clear the upper 96 bits.
            let bitmaskAddress := shr(96, not(0))
            from := and(bitmaskAddress, from)
            to := and(bitmaskAddress, to)
            by := and(bitmaskAddress, by)
            // Load the ownership data.
            mstore(0x00, id)
            mstore(0x1c, or(_ERC721_MASTER_SLOT_SEED, by))
            let ownershipSlot := add(id, add(id, keccak256(0x00, 0x20)))
            let ownershipPacked := sload(ownershipSlot)
            let owner := and(bitmaskAddress, ownershipPacked)
            // Revert if `from` is not the owner, or does not exist.
            if iszero(mul(owner, eq(owner, from))) {
                if iszero(owner) {
                    mstore(0x00, 0xceea21b6) // `TokenDoesNotExist()`.
                    revert(0x1c, 0x04)
                }
                mstore(0x00, 0xa1148100) // `TransferFromIncorrectOwner()`.
                revert(0x1c, 0x04)
            }
            // Revert if `to` is the zero address.
            if iszero(to) {
                mstore(0x00, 0xea553b34) // `TransferToZeroAddress()`.
                revert(0x1c, 0x04)
            }
            // Load, check, and update the token approval.
            {
                mstore(0x00, from)
                let approvedAddress := sload(add(1, ownershipSlot))
                // If `by` is not the zero address, do the authorization check.
                // Revert if the `by` is not the owner, nor approved.
                if iszero(or(iszero(by), or(eq(by, from), eq(by, approvedAddress)))) {
                    if iszero(sload(keccak256(0x0c, 0x30))) {
                        mstore(0x00, 0x4b6e7f18) // `NotOwnerNorApproved()`.
                        revert(0x1c, 0x04)
                    }
                }
                // Delete the approved address if any.
                if approvedAddress { sstore(add(1, ownershipSlot), 0) }
            }
            // Update with the new owner.
            sstore(ownershipSlot, xor(ownershipPacked, xor(from, to)))
            // Decrement the balance of `from`.
            {
                let fromBalanceSlot := keccak256(0x0c, 0x1c)
                sstore(fromBalanceSlot, sub(sload(fromBalanceSlot), 1))
            }
            // Increment the balance of `to`.
            {
                mstore(0x00, to)
                let toBalanceSlot := keccak256(0x0c, 0x1c)
                let toBalanceSlotPacked := add(sload(toBalanceSlot), 1)
                if iszero(and(toBalanceSlotPacked, _MAX_ACCOUNT_BALANCE)) {
                    mstore(0x00, 0x01336cea) // `AccountBalanceOverflow()`.
                    revert(0x1c, 0x04)
                }
                sstore(toBalanceSlot, toBalanceSlotPacked)
            }
            // Emit the {Transfer} event.
            log4(0x00, 0x00, _TRANSFER_EVENT_SIGNATURE, from, to, id)
        }
        _afterTokenTransfer(from, to, id);
    }

    /// @dev Equivalent to `_safeTransfer(from, to, id, "")`.
    function _safeTransfer(address from, address to, uint256 id) internal virtual {
        _safeTransfer(from, to, id, "");
    }

    /// @dev Transfers token `id` from `from` to `to`.
    ///
    /// Requirements:
    ///
    /// - Token `id` must exist.
    /// - `from` must be the owner of the token.
    /// - `to` cannot be the zero address.
    /// - The caller must be the owner of the token, or be approved to manage the token.
    /// - If `to` refers to a smart contract, it must implement
    ///   {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
    ///
    /// Emits a {Transfer} event.
    function _safeTransfer(address from, address to, uint256 id, bytes memory data)
        internal
        virtual
    {
        _transfer(address(0), from, to, id);
        if (_hasCode(to)) _checkOnERC721Received(from, to, id, data);
    }

    /// @dev Equivalent to `_safeTransfer(by, from, to, id, "")`.
    function _safeTransfer(address by, address from, address to, uint256 id) internal virtual {
        _safeTransfer(by, from, to, id, "");
    }

    /// @dev Transfers token `id` from `from` to `to`.
    ///
    /// Requirements:
    ///
    /// - Token `id` must exist.
    /// - `from` must be the owner of the token.
    /// - `to` cannot be the zero address.
    /// - If `by` is not the zero address,
    ///   it must be the owner of the token, or be approved to manage the token.
    /// - If `to` refers to a smart contract, it must implement
    ///   {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
    ///
    /// Emits a {Transfer} event.
    function _safeTransfer(address by, address from, address to, uint256 id, bytes memory data)
        internal
        virtual
    {
        _transfer(by, from, to, id);
        if (_hasCode(to)) _checkOnERC721Received(from, to, id, data);
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                    HOOKS FOR OVERRIDING                    */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Hook that is called before any token transfers, including minting and burning.
    function _beforeTokenTransfer(address from, address to, uint256 id) internal virtual {}

    /// @dev Hook that is called after any token transfers, including minting and burning.
    function _afterTokenTransfer(address from, address to, uint256 id) internal virtual {}

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                      PRIVATE HELPERS                       */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns if `a` has bytecode of non-zero length.
    function _hasCode(address a) private view returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := extcodesize(a) // Can handle dirty upper bits.
        }
    }

    /// @dev Perform a call to invoke {IERC721Receiver-onERC721Received} on `to`.
    /// Reverts if the target does not support the function correctly.
    function _checkOnERC721Received(address from, address to, uint256 id, bytes memory data)
        private
    {
        /// @solidity memory-safe-assembly
        assembly {
            // Prepare the calldata.
            let m := mload(0x40)
            let onERC721ReceivedSelector := 0x150b7a02
            mstore(m, onERC721ReceivedSelector)
            mstore(add(m, 0x20), caller()) // The `operator`, which is always `msg.sender`.
            mstore(add(m, 0x40), shr(96, shl(96, from)))
            mstore(add(m, 0x60), id)
            mstore(add(m, 0x80), 0x80)
            let n := mload(data)
            mstore(add(m, 0xa0), n)
            if n { pop(staticcall(gas(), 4, add(data, 0x20), n, add(m, 0xc0), n)) }
            // Revert if the call reverts.
            if iszero(call(gas(), to, 0, add(m, 0x1c), add(n, 0xa4), m, 0x20)) {
                if returndatasize() {
                    // Bubble up the revert if the delegatecall reverts.
                    returndatacopy(0x00, 0x00, returndatasize())
                    revert(0x00, returndatasize())
                }
                mstore(m, 0)
            }
            // Load the returndata and compare it.
            if iszero(eq(mload(m), shl(224, onERC721ReceivedSelector))) {
                mstore(0x00, 0xd1a57ed6) // `TransferToNonERC721ReceiverImplementer()`.
                revert(0x1c, 0x04)
            }
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

/// @notice Library to encode strings in Base64.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/Base64.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/Base64.sol)
/// @author Modified from (https://github.com/Brechtpd/base64/blob/main/base64.sol) by Brecht Devos - <[email protected]>.
library Base64 {
    /// @dev Encodes `data` using the base64 encoding described in RFC 4648.
    /// See: https://datatracker.ietf.org/doc/html/rfc4648
    /// @param fileSafe  Whether to replace '+' with '-' and '/' with '_'.
    /// @param noPadding Whether to strip away the padding.
    function encode(bytes memory data, bool fileSafe, bool noPadding)
        internal
        pure
        returns (string memory result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let dataLength := mload(data)

            if dataLength {
                // Multiply by 4/3 rounded up.
                // The `shl(2, ...)` is equivalent to multiplying by 4.
                let encodedLength := shl(2, div(add(dataLength, 2), 3))

                // Set `result` to point to the start of the free memory.
                result := mload(0x40)

                // Store the table into the scratch space.
                // Offsetted by -1 byte so that the `mload` will load the character.
                // We will rewrite the free memory pointer at `0x40` later with
                // the allocated size.
                // The magic constant 0x0230 will translate "-_" + "+/".
                mstore(0x1f, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdef")
                mstore(0x3f, sub("ghijklmnopqrstuvwxyz0123456789-_", mul(iszero(fileSafe), 0x0230)))

                // Skip the first slot, which stores the length.
                let ptr := add(result, 0x20)
                let end := add(ptr, encodedLength)

                // Run over the input, 3 bytes at a time.
                for {} 1 {} {
                    data := add(data, 3) // Advance 3 bytes.
                    let input := mload(data)

                    // Write 4 bytes. Optimized for fewer stack operations.
                    mstore8(0, mload(and(shr(18, input), 0x3F)))
                    mstore8(1, mload(and(shr(12, input), 0x3F)))
                    mstore8(2, mload(and(shr(6, input), 0x3F)))
                    mstore8(3, mload(and(input, 0x3F)))
                    mstore(ptr, mload(0x00))

                    ptr := add(ptr, 4) // Advance 4 bytes.
                    if iszero(lt(ptr, end)) { break }
                }
                mstore(0x40, add(end, 0x20)) // Allocate the memory.
                // Equivalent to `o = [0, 2, 1][dataLength % 3]`.
                let o := div(2, mod(dataLength, 3))
                // Offset `ptr` and pad with '='. We can simply write over the end.
                mstore(sub(ptr, o), shl(240, 0x3d3d))
                // Set `o` to zero if there is padding.
                o := mul(iszero(iszero(noPadding)), o)
                mstore(sub(ptr, o), 0) // Zeroize the slot after the string.
                mstore(result, sub(encodedLength, o)) // Store the length.
            }
        }
    }

    /// @dev Encodes `data` using the base64 encoding described in RFC 4648.
    /// Equivalent to `encode(data, false, false)`.
    function encode(bytes memory data) internal pure returns (string memory result) {
        result = encode(data, false, false);
    }

    /// @dev Encodes `data` using the base64 encoding described in RFC 4648.
    /// Equivalent to `encode(data, fileSafe, false)`.
    function encode(bytes memory data, bool fileSafe)
        internal
        pure
        returns (string memory result)
    {
        result = encode(data, fileSafe, false);
    }

    /// @dev Decodes base64 encoded `data`.
    ///
    /// Supports:
    /// - RFC 4648 (both standard and file-safe mode).
    /// - RFC 3501 (63: ',').
    ///
    /// Does not support:
    /// - Line breaks.
    ///
    /// Note: For performance reasons,
    /// this function will NOT revert on invalid `data` inputs.
    /// Outputs for invalid inputs will simply be undefined behaviour.
    /// It is the user's responsibility to ensure that the `data`
    /// is a valid base64 encoded string.
    function decode(string memory data) internal pure returns (bytes memory result) {
        /// @solidity memory-safe-assembly
        assembly {
            let dataLength := mload(data)

            if dataLength {
                let decodedLength := mul(shr(2, dataLength), 3)

                for {} 1 {} {
                    // If padded.
                    if iszero(and(dataLength, 3)) {
                        let t := xor(mload(add(data, dataLength)), 0x3d3d)
                        // forgefmt: disable-next-item
                        decodedLength := sub(
                            decodedLength,
                            add(iszero(byte(30, t)), iszero(byte(31, t)))
                        )
                        break
                    }
                    // If non-padded.
                    decodedLength := add(decodedLength, sub(and(dataLength, 3), 1))
                    break
                }
                result := mload(0x40)

                // Write the length of the bytes.
                mstore(result, decodedLength)

                // Skip the first slot, which stores the length.
                let ptr := add(result, 0x20)
                let end := add(ptr, decodedLength)

                // Load the table into the scratch space.
                // Constants are optimized for smaller bytecode with zero gas overhead.
                // `m` also doubles as the mask of the upper 6 bits.
                let m := 0xfc000000fc00686c7074787c8084888c9094989ca0a4a8acb0b4b8bcc0c4c8cc
                mstore(0x5b, m)
                mstore(0x3b, 0x04080c1014181c2024282c3034383c4044484c5054585c6064)
                mstore(0x1a, 0xf8fcf800fcd0d4d8dce0e4e8ecf0f4)

                for {} 1 {} {
                    // Read 4 bytes.
                    data := add(data, 4)
                    let input := mload(data)

                    // Write 3 bytes.
                    // forgefmt: disable-next-item
                    mstore(ptr, or(
                        and(m, mload(byte(28, input))),
                        shr(6, or(
                            and(m, mload(byte(29, input))),
                            shr(6, or(
                                and(m, mload(byte(30, input))),
                                shr(6, mload(byte(31, input)))
                            ))
                        ))
                    ))
                    ptr := add(ptr, 3)
                    if iszero(lt(ptr, end)) { break }
                }
                mstore(0x40, add(end, 0x20)) // Allocate the memory.
                mstore(end, 0) // Zeroize the slot after the bytes.
                mstore(0x60, 0) // Restore the zero slot.
            }
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

/// @notice Library for buffers with automatic capacity resizing.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/DynamicBuffer.sol)
/// @author Modified from cozyco (https://github.com/samkingco/cozyco/blob/main/contracts/utils/DynamicBuffer.sol)
library DynamicBufferLib {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          STRUCTS                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Type to represent a dynamic buffer in memory.
    /// You can directly assign to `data`, and the `append` function will
    /// take care of the memory allocation.
    struct DynamicBuffer {
        bytes data;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         OPERATIONS                         */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Appends `data` to `buffer`.
    /// Returns the same buffer, so that it can be used for function chaining.
    function append(DynamicBuffer memory buffer, bytes memory data)
        internal
        pure
        returns (DynamicBuffer memory)
    {
        /// @solidity memory-safe-assembly
        assembly {
            if mload(data) {
                let w := not(0x1f)
                let bufferData := mload(buffer)
                let bufferDataLength := mload(bufferData)
                let newBufferDataLength := add(mload(data), bufferDataLength)
                // Some random prime number to multiply `capacity`, so that
                // we know that the `capacity` is for a dynamic buffer.
                // Selected to be larger than any memory pointer realistically.
                let prime := 1621250193422201
                let capacity := mload(add(bufferData, w))

                // Extract `capacity`, and set it to 0, if it is not a multiple of `prime`.
                capacity := mul(div(capacity, prime), iszero(mod(capacity, prime)))

                // Expand / Reallocate memory if required.
                // Note that we need to allocate an exta word for the length, and
                // and another extra word as a safety word (giving a total of 0x40 bytes).
                // Without the safety word, the data at the next free memory word can be overwritten,
                // because the backwards copying can exceed the buffer space used for storage.
                for {} iszero(lt(newBufferDataLength, capacity)) {} {
                    // Approximately double the memory with a heuristic,
                    // ensuring more than enough space for the combined data,
                    // rounding up to the next multiple of 32.
                    let newCapacity :=
                        and(add(capacity, add(or(capacity, newBufferDataLength), 0x20)), w)

                    // If next word after current buffer is not eligible for use.
                    if iszero(eq(mload(0x40), add(bufferData, add(0x40, capacity)))) {
                        // Set the `newBufferData` to point to the word after capacity.
                        let newBufferData := add(mload(0x40), 0x20)
                        // Reallocate the memory.
                        mstore(0x40, add(newBufferData, add(0x40, newCapacity)))
                        // Store the `newBufferData`.
                        mstore(buffer, newBufferData)
                        // Copy `bufferData` one word at a time, backwards.
                        for { let o := and(add(bufferDataLength, 0x20), w) } 1 {} {
                            mstore(add(newBufferData, o), mload(add(bufferData, o)))
                            o := add(o, w) // `sub(o, 0x20)`.
                            if iszero(o) { break }
                        }
                        // Store the `capacity` multiplied by `prime` in the word before the `length`.
                        mstore(add(newBufferData, w), mul(prime, newCapacity))
                        // Assign `newBufferData` to `bufferData`.
                        bufferData := newBufferData
                        break
                    }
                    // Expand the memory.
                    mstore(0x40, add(bufferData, add(0x40, newCapacity)))
                    // Store the `capacity` multiplied by `prime` in the word before the `length`.
                    mstore(add(bufferData, w), mul(prime, newCapacity))
                    break
                }
                // Initalize `output` to the next empty position in `bufferData`.
                let output := add(bufferData, bufferDataLength)
                // Copy `data` one word at a time, backwards.
                for { let o := and(add(mload(data), 0x20), w) } 1 {} {
                    mstore(add(output, o), mload(add(data, o)))
                    o := add(o, w) // `sub(o, 0x20)`.
                    if iszero(o) { break }
                }
                // Zeroize the word after the buffer.
                mstore(add(add(bufferData, 0x20), newBufferDataLength), 0)
                // Store the `newBufferDataLength`.
                mstore(bufferData, newBufferDataLength)
            }
        }
        return buffer;
    }

    /// @dev Appends `data0`, `data1` to `buffer`.
    /// Returns the same buffer, so that it can be used for function chaining.
    function append(DynamicBuffer memory buffer, bytes memory data0, bytes memory data1)
        internal
        pure
        returns (DynamicBuffer memory)
    {
        return append(append(buffer, data0), data1);
    }

    /// @dev Appends `data0`, `data1`, `data2` to `buffer`.
    /// Returns the same buffer, so that it can be used for function chaining.
    function append(
        DynamicBuffer memory buffer,
        bytes memory data0,
        bytes memory data1,
        bytes memory data2
    ) internal pure returns (DynamicBuffer memory) {
        return append(append(append(buffer, data0), data1), data2);
    }

    /// @dev Appends `data0`, `data1`, `data2`, `data3` to `buffer`.
    /// Returns the same buffer, so that it can be used for function chaining.
    function append(
        DynamicBuffer memory buffer,
        bytes memory data0,
        bytes memory data1,
        bytes memory data2,
        bytes memory data3
    ) internal pure returns (DynamicBuffer memory) {
        return append(append(append(append(buffer, data0), data1), data2), data3);
    }

    /// @dev Appends `data0`, `data1`, `data2`, `data3`, `data4` to `buffer`.
    /// Returns the same buffer, so that it can be used for function chaining.
    function append(
        DynamicBuffer memory buffer,
        bytes memory data0,
        bytes memory data1,
        bytes memory data2,
        bytes memory data3,
        bytes memory data4
    ) internal pure returns (DynamicBuffer memory) {
        append(append(append(append(buffer, data0), data1), data2), data3);
        return append(buffer, data4);
    }

    /// @dev Appends `data0`, `data1`, `data2`, `data3`, `data4`, `data5` to `buffer`.
    /// Returns the same buffer, so that it can be used for function chaining.
    function append(
        DynamicBuffer memory buffer,
        bytes memory data0,
        bytes memory data1,
        bytes memory data2,
        bytes memory data3,
        bytes memory data4,
        bytes memory data5
    ) internal pure returns (DynamicBuffer memory) {
        append(append(append(append(buffer, data0), data1), data2), data3);
        return append(append(buffer, data4), data5);
    }

    /// @dev Appends `data0`, `data1`, `data2`, `data3`, `data4`, `data5`, `data6` to `buffer`.
    /// Returns the same buffer, so that it can be used for function chaining.
    function append(
        DynamicBuffer memory buffer,
        bytes memory data0,
        bytes memory data1,
        bytes memory data2,
        bytes memory data3,
        bytes memory data4,
        bytes memory data5,
        bytes memory data6
    ) internal pure returns (DynamicBuffer memory) {
        append(append(append(append(buffer, data0), data1), data2), data3);
        return append(append(append(buffer, data4), data5), data6);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

/// @notice Library for generating psuedorandom numbers.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibPRNG.sol)
library LibPRNG {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          STRUCTS                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev A psuedorandom number state in memory.
    struct PRNG {
        uint256 state;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         OPERATIONS                         */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Seeds the `prng` with `state`.
    function seed(PRNG memory prng, uint256 state) internal pure {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(prng, state)
        }
    }

    /// @dev Returns the next psuedorandom uint256.
    /// All bits of the returned uint256 pass the NIST Statistical Test Suite.
    function next(PRNG memory prng) internal pure returns (uint256 result) {
        // We simply use `keccak256` for a great balance between
        // runtime gas costs, bytecode size, and statistical properties.
        //
        // A high-quality LCG with a 32-byte state
        // is only about 30% more gas efficient during runtime,
        // but requires a 32-byte multiplier, which can cause bytecode bloat
        // when this function is inlined.
        //
        // Using this method is about 2x more efficient than
        // `nextRandomness = uint256(keccak256(abi.encode(randomness)))`.
        /// @solidity memory-safe-assembly
        assembly {
            result := keccak256(prng, 0x20)
            mstore(prng, result)
        }
    }

    /// @dev Returns a psuedorandom uint256, uniformly distributed
    /// between 0 (inclusive) and `upper` (exclusive).
    /// If your modulus is big, this method is recommended
    /// for uniform sampling to avoid modulo bias.
    /// For uniform sampling across all uint256 values,
    /// or for small enough moduli such that the bias is neligible,
    /// use {next} instead.
    function uniform(PRNG memory prng, uint256 upper) internal pure returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            for {} 1 {} {
                result := keccak256(prng, 0x20)
                mstore(prng, result)
                if iszero(lt(result, mod(sub(0, upper), upper))) { break }
            }
            result := mod(result, upper)
        }
    }

    /// @dev Shuffles the array in-place with Fisher-Yates shuffle.
    function shuffle(PRNG memory prng, uint256[] memory a) internal pure {
        /// @solidity memory-safe-assembly
        assembly {
            let n := mload(a)
            let w := not(0)
            let mask := shr(128, w)
            if n {
                for { a := add(a, 0x20) } 1 {} {
                    // We can just directly use `keccak256`, cuz
                    // the other approaches don't save much.
                    let r := keccak256(prng, 0x20)
                    mstore(prng, r)

                    // Note that there will be a very tiny modulo bias
                    // if the length of the array is not a power of 2.
                    // For all practical purposes, it is negligible
                    // and will not be a fairness or security concern.
                    {
                        let j := add(a, shl(5, mod(shr(128, r), n)))
                        n := add(n, w) // `sub(n, 1)`.
                        if iszero(n) { break }

                        let i := add(a, shl(5, n))
                        let t := mload(i)
                        mstore(i, mload(j))
                        mstore(j, t)
                    }

                    {
                        let j := add(a, shl(5, mod(and(r, mask), n)))
                        n := add(n, w) // `sub(n, 1)`.
                        if iszero(n) { break }

                        let i := add(a, shl(5, n))
                        let t := mload(i)
                        mstore(i, mload(j))
                        mstore(j, t)
                    }
                }
            }
        }
    }

    /// @dev Shuffles the bytes in-place with Fisher-Yates shuffle.
    function shuffle(PRNG memory prng, bytes memory a) internal pure {
        /// @solidity memory-safe-assembly
        assembly {
            let n := mload(a)
            let w := not(0)
            let mask := shr(128, w)
            if n {
                let b := add(a, 0x01)
                for { a := add(a, 0x20) } 1 {} {
                    // We can just directly use `keccak256`, cuz
                    // the other approaches don't save much.
                    let r := keccak256(prng, 0x20)
                    mstore(prng, r)

                    // Note that there will be a very tiny modulo bias
                    // if the length of the array is not a power of 2.
                    // For all practical purposes, it is negligible
                    // and will not be a fairness or security concern.
                    {
                        let o := mod(shr(128, r), n)
                        n := add(n, w) // `sub(n, 1)`.
                        if iszero(n) { break }

                        let t := mload(add(b, n))
                        mstore8(add(a, n), mload(add(b, o)))
                        mstore8(add(a, o), t)
                    }

                    {
                        let o := mod(and(r, mask), n)
                        n := add(n, w) // `sub(n, 1)`.
                        if iszero(n) { break }

                        let t := mload(add(b, n))
                        mstore8(add(a, n), mload(add(b, o)))
                        mstore8(add(a, o), t)
                    }
                }
            }
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

/// @notice Library for converting numbers into strings and other string operations.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibString.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/LibString.sol)
library LibString {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                        CUSTOM ERRORS                       */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The `length` of the output is too small to contain all the hex digits.
    error HexLengthInsufficient();

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         CONSTANTS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The constant returned when the `search` is not found in the string.
    uint256 internal constant NOT_FOUND = type(uint256).max;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                     DECIMAL OPERATIONS                     */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the base 10 decimal representation of `value`.
    function toString(uint256 value) internal pure returns (string memory str) {
        /// @solidity memory-safe-assembly
        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.
            str := add(mload(0x40), 0x80)
            // Update the free memory pointer to allocate.
            mstore(0x40, add(str, 0x20))
            // Zeroize the slot after the string.
            mstore(str, 0)

            // Cache the end of the memory to calculate the length later.
            let end := str

            let w := not(0) // Tsk.
            // We write the string from rightmost digit to leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            for { let temp := value } 1 {} {
                str := add(str, w) // `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)
                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 Returns the base 10 decimal representation of `value`.
    function toString(int256 value) internal pure returns (string memory str) {
        if (value >= 0) {
            return toString(uint256(value));
        }
        unchecked {
            str = toString(uint256(-value));
        }
        /// @solidity memory-safe-assembly
        assembly {
            // We still have some spare memory space on the left,
            // as we have allocated 3 words (96 bytes) for up to 78 digits.
            let length := mload(str) // Load the string length.
            mstore(str, 0x2d) // Store the '-' character.
            str := sub(str, 1) // Move back the string pointer by a byte.
            mstore(str, add(length, 1)) // Update the string length.
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                   HEXADECIMAL OPERATIONS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the hexadecimal representation of `value`,
    /// left-padded to an input length of `length` bytes.
    /// The output is prefixed with "0x" encoded using 2 hexadecimal digits per byte,
    /// giving a total length of `length * 2 + 2` bytes.
    /// Reverts if `length` is too small for the output to contain all the digits.
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory str) {
        str = toHexStringNoPrefix(value, length);
        /// @solidity memory-safe-assembly
        assembly {
            let strLength := add(mload(str), 2) // Compute the length.
            mstore(str, 0x3078) // Write the "0x" prefix.
            str := sub(str, 2) // Move the pointer.
            mstore(str, strLength) // Write the length.
        }
    }

    /// @dev Returns the hexadecimal representation of `value`,
    /// left-padded to an input length of `length` bytes.
    /// The output is prefixed with "0x" encoded using 2 hexadecimal digits per byte,
    /// giving a total length of `length * 2` bytes.
    /// Reverts if `length` is too small for the output to contain all the digits.
    function toHexStringNoPrefix(uint256 value, uint256 length)
        internal
        pure
        returns (string memory str)
    {
        /// @solidity memory-safe-assembly
        assembly {
            // We need 0x20 bytes for the trailing zeros padding, `length * 2` bytes
            // for the digits, 0x02 bytes for the prefix, and 0x20 bytes for the length.
            // We add 0x20 to the total and round down to a multiple of 0x20.
            // (0x20 + 0x20 + 0x02 + 0x20) = 0x62.
            str := add(mload(0x40), and(add(shl(1, length), 0x42), not(0x1f)))
            // Allocate the memory.
            mstore(0x40, add(str, 0x20))
            // Zeroize the slot after the string.
            mstore(str, 0)

            // Cache the end to calculate the length later.
            let end := str
            // Store "0123456789abcdef" in scratch space.
            mstore(0x0f, 0x30313233343536373839616263646566)

            let start := sub(str, add(length, length))
            let w := not(1) // Tsk.
            let temp := value
            // We write the string from rightmost digit to leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            for {} 1 {} {
                str := add(str, w) // `sub(str, 2)`.
                mstore8(add(str, 1), mload(and(temp, 15)))
                mstore8(str, mload(and(shr(4, temp), 15)))
                temp := shr(8, temp)
                if iszero(xor(str, start)) { break }
            }

            if temp {
                // Store the function selector of `HexLengthInsufficient()`.
                mstore(0x00, 0x2194895a)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }

            // Compute the string's length.
            let strLength := sub(end, str)
            // Move the pointer and write the length.
            str := sub(str, 0x20)
            mstore(str, strLength)
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output is prefixed with "0x" and encoded using 2 hexadecimal digits per byte.
    /// As address are 20 bytes long, the output will left-padded to have
    /// a length of `20 * 2 + 2` bytes.
    function toHexString(uint256 value) internal pure returns (string memory str) {
        str = toHexStringNoPrefix(value);
        /// @solidity memory-safe-assembly
        assembly {
            let strLength := add(mload(str), 2) // Compute the length.
            mstore(str, 0x3078) // Write the "0x" prefix.
            str := sub(str, 2) // Move the pointer.
            mstore(str, strLength) // Write the length.
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output is encoded using 2 hexadecimal digits per byte.
    /// As address are 20 bytes long, the output will left-padded to have
    /// a length of `20 * 2` bytes.
    function toHexStringNoPrefix(uint256 value) internal pure returns (string memory str) {
        /// @solidity memory-safe-assembly
        assembly {
            // We need 0x20 bytes for the trailing zeros padding, 0x20 bytes for the length,
            // 0x02 bytes for the prefix, and 0x40 bytes for the digits.
            // The next multiple of 0x20 above (0x20 + 0x20 + 0x02 + 0x40) is 0xa0.
            str := add(mload(0x40), 0x80)
            // Allocate the memory.
            mstore(0x40, add(str, 0x20))
            // Zeroize the slot after the string.
            mstore(str, 0)

            // Cache the end to calculate the length later.
            let end := str
            // Store "0123456789abcdef" in scratch space.
            mstore(0x0f, 0x30313233343536373839616263646566)

            let w := not(1) // Tsk.
            // We write the string from rightmost digit to leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            for { let temp := value } 1 {} {
                str := add(str, w) // `sub(str, 2)`.
                mstore8(add(str, 1), mload(and(temp, 15)))
                mstore8(str, mload(and(shr(4, temp), 15)))
                temp := shr(8, temp)
                if iszero(temp) { break }
            }

            // Compute the string's length.
            let strLength := sub(end, str)
            // Move the pointer and write the length.
            str := sub(str, 0x20)
            mstore(str, strLength)
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output is prefixed with "0x", encoded using 2 hexadecimal digits per byte,
    /// and the alphabets are capitalized conditionally according to
    /// https://eips.ethereum.org/EIPS/eip-55
    function toHexStringChecksumed(address value) internal pure returns (string memory str) {
        str = toHexString(value);
        /// @solidity memory-safe-assembly
        assembly {
            let mask := shl(6, div(not(0), 255)) // `0b010000000100000000 ...`
            let o := add(str, 0x22)
            let hashed := and(keccak256(o, 40), mul(34, mask)) // `0b10001000 ... `
            let t := shl(240, 136) // `0b10001000 << 240`
            for { let i := 0 } 1 {} {
                mstore(add(i, i), mul(t, byte(i, hashed)))
                i := add(i, 1)
                if eq(i, 20) { break }
            }
            mstore(o, xor(mload(o), shr(1, and(mload(0x00), and(mload(o), mask)))))
            o := add(o, 0x20)
            mstore(o, xor(mload(o), shr(1, and(mload(0x20), and(mload(o), mask)))))
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output is prefixed with "0x" and encoded using 2 hexadecimal digits per byte.
    function toHexString(address value) internal pure returns (string memory str) {
        str = toHexStringNoPrefix(value);
        /// @solidity memory-safe-assembly
        assembly {
            let strLength := add(mload(str), 2) // Compute the length.
            mstore(str, 0x3078) // Write the "0x" prefix.
            str := sub(str, 2) // Move the pointer.
            mstore(str, strLength) // Write the length.
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output is encoded using 2 hexadecimal digits per byte.
    function toHexStringNoPrefix(address value) internal pure returns (string memory str) {
        /// @solidity memory-safe-assembly
        assembly {
            str := mload(0x40)

            // Allocate the memory.
            // We need 0x20 bytes for the trailing zeros padding, 0x20 bytes for the length,
            // 0x02 bytes for the prefix, and 0x28 bytes for the digits.
            // The next multiple of 0x20 above (0x20 + 0x20 + 0x02 + 0x28) is 0x80.
            mstore(0x40, add(str, 0x80))

            // Store "0123456789abcdef" in scratch space.
            mstore(0x0f, 0x30313233343536373839616263646566)

            str := add(str, 2)
            mstore(str, 40)

            let o := add(str, 0x20)
            mstore(add(o, 40), 0)

            value := shl(96, value)

            // We write the string from rightmost digit to leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            for { let i := 0 } 1 {} {
                let p := add(o, add(i, i))
                let temp := byte(i, value)
                mstore8(add(p, 1), mload(and(temp, 15)))
                mstore8(p, mload(shr(4, temp)))
                i := add(i, 1)
                if eq(i, 20) { break }
            }
        }
    }

    /// @dev Returns the hex encoded string from the raw bytes.
    /// The output is encoded using 2 hexadecimal digits per byte.
    function toHexString(bytes memory raw) internal pure returns (string memory str) {
        str = toHexStringNoPrefix(raw);
        /// @solidity memory-safe-assembly
        assembly {
            let strLength := add(mload(str), 2) // Compute the length.
            mstore(str, 0x3078) // Write the "0x" prefix.
            str := sub(str, 2) // Move the pointer.
            mstore(str, strLength) // Write the length.
        }
    }

    /// @dev Returns the hex encoded string from the raw bytes.
    /// The output is encoded using 2 hexadecimal digits per byte.
    function toHexStringNoPrefix(bytes memory raw) internal pure returns (string memory str) {
        /// @solidity memory-safe-assembly
        assembly {
            let length := mload(raw)
            str := add(mload(0x40), 2) // Skip 2 bytes for the optional prefix.
            mstore(str, add(length, length)) // Store the length of the output.

            // Store "0123456789abcdef" in scratch space.
            mstore(0x0f, 0x30313233343536373839616263646566)

            let o := add(str, 0x20)
            let end := add(raw, length)

            for {} iszero(eq(raw, end)) {} {
                raw := add(raw, 1)
                mstore8(add(o, 1), mload(and(mload(raw), 15)))
                mstore8(o, mload(and(shr(4, mload(raw)), 15)))
                o := add(o, 2)
            }
            mstore(o, 0) // Zeroize the slot after the string.
            mstore(0x40, add(o, 0x20)) // Allocate the memory.
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                   RUNE STRING OPERATIONS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the number of UTF characters in the string.
    function runeCount(string memory s) internal pure returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            if mload(s) {
                mstore(0x00, div(not(0), 255))
                mstore(0x20, 0x0202020202020202020202020202020202020202020202020303030304040506)
                let o := add(s, 0x20)
                let end := add(o, mload(s))
                for { result := 1 } 1 { result := add(result, 1) } {
                    o := add(o, byte(0, mload(shr(250, mload(o)))))
                    if iszero(lt(o, end)) { break }
                }
            }
        }
    }

    /// @dev Returns if this string is a 7-bit ASCII string.
    /// (i.e. all characters codes are in [0..127])
    function is7BitASCII(string memory s) internal pure returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            let mask := shl(7, div(not(0), 255))
            result := 1
            let n := mload(s)
            if n {
                let o := add(s, 0x20)
                let end := add(o, n)
                let last := mload(end)
                mstore(end, 0)
                for {} 1 {} {
                    if and(mask, mload(o)) {
                        result := 0
                        break
                    }
                    o := add(o, 0x20)
                    if iszero(lt(o, end)) { break }
                }
                mstore(end, last)
            }
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                   BYTE STRING OPERATIONS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    // For performance and bytecode compactness, all indices of the following operations
    // are byte (ASCII) offsets, not UTF character offsets.

    /// @dev Returns `subject` all occurrences of `search` replaced with `replacement`.
    function replace(string memory subject, string memory search, string memory replacement)
        internal
        pure
        returns (string memory result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let subjectLength := mload(subject)
            let searchLength := mload(search)
            let replacementLength := mload(replacement)

            subject := add(subject, 0x20)
            search := add(search, 0x20)
            replacement := add(replacement, 0x20)
            result := add(mload(0x40), 0x20)

            let subjectEnd := add(subject, subjectLength)
            if iszero(gt(searchLength, subjectLength)) {
                let subjectSearchEnd := add(sub(subjectEnd, searchLength), 1)
                let h := 0
                if iszero(lt(searchLength, 0x20)) { h := keccak256(search, searchLength) }
                let m := shl(3, sub(0x20, and(searchLength, 0x1f)))
                let s := mload(search)
                for {} 1 {} {
                    let t := mload(subject)
                    // Whether the first `searchLength % 32` bytes of
                    // `subject` and `search` matches.
                    if iszero(shr(m, xor(t, s))) {
                        if h {
                            if iszero(eq(keccak256(subject, searchLength), h)) {
                                mstore(result, t)
                                result := add(result, 1)
                                subject := add(subject, 1)
                                if iszero(lt(subject, subjectSearchEnd)) { break }
                                continue
                            }
                        }
                        // Copy the `replacement` one word at a time.
                        for { let o := 0 } 1 {} {
                            mstore(add(result, o), mload(add(replacement, o)))
                            o := add(o, 0x20)
                            if iszero(lt(o, replacementLength)) { break }
                        }
                        result := add(result, replacementLength)
                        subject := add(subject, searchLength)
                        if searchLength {
                            if iszero(lt(subject, subjectSearchEnd)) { break }
                            continue
                        }
                    }
                    mstore(result, t)
                    result := add(result, 1)
                    subject := add(subject, 1)
                    if iszero(lt(subject, subjectSearchEnd)) { break }
                }
            }

            let resultRemainder := result
            result := add(mload(0x40), 0x20)
            let k := add(sub(resultRemainder, result), sub(subjectEnd, subject))
            // Copy the rest of the string one word at a time.
            for {} lt(subject, subjectEnd) {} {
                mstore(resultRemainder, mload(subject))
                resultRemainder := add(resultRemainder, 0x20)
                subject := add(subject, 0x20)
            }
            result := sub(result, 0x20)
            let last := add(add(result, 0x20), k) // Zeroize the slot after the string.
            mstore(last, 0)
            mstore(0x40, add(last, 0x20)) // Allocate the memory.
            mstore(result, k) // Store the length.
        }
    }

    /// @dev Returns the byte index of the first location of `search` in `subject`,
    /// searching from left to right, starting from `from`.
    /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found.
    function indexOf(string memory subject, string memory search, uint256 from)
        internal
        pure
        returns (uint256 result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            for { let subjectLength := mload(subject) } 1 {} {
                if iszero(mload(search)) {
                    if iszero(gt(from, subjectLength)) {
                        result := from
                        break
                    }
                    result := subjectLength
                    break
                }
                let searchLength := mload(search)
                let subjectStart := add(subject, 0x20)

                result := not(0) // Initialize to `NOT_FOUND`.

                subject := add(subjectStart, from)
                let end := add(sub(add(subjectStart, subjectLength), searchLength), 1)

                let m := shl(3, sub(0x20, and(searchLength, 0x1f)))
                let s := mload(add(search, 0x20))

                if iszero(and(lt(subject, end), lt(from, subjectLength))) { break }

                if iszero(lt(searchLength, 0x20)) {
                    for { let h := keccak256(add(search, 0x20), searchLength) } 1 {} {
                        if iszero(shr(m, xor(mload(subject), s))) {
                            if eq(keccak256(subject, searchLength), h) {
                                result := sub(subject, subjectStart)
                                break
                            }
                        }
                        subject := add(subject, 1)
                        if iszero(lt(subject, end)) { break }
                    }
                    break
                }
                for {} 1 {} {
                    if iszero(shr(m, xor(mload(subject), s))) {
                        result := sub(subject, subjectStart)
                        break
                    }
                    subject := add(subject, 1)
                    if iszero(lt(subject, end)) { break }
                }
                break
            }
        }
    }

    /// @dev Returns the byte index of the first location of `search` in `subject`,
    /// searching from left to right.
    /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found.
    function indexOf(string memory subject, string memory search)
        internal
        pure
        returns (uint256 result)
    {
        result = indexOf(subject, search, 0);
    }

    /// @dev Returns the byte index of the first location of `search` in `subject`,
    /// searching from right to left, starting from `from`.
    /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found.
    function lastIndexOf(string memory subject, string memory search, uint256 from)
        internal
        pure
        returns (uint256 result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            for {} 1 {} {
                result := not(0) // Initialize to `NOT_FOUND`.
                let searchLength := mload(search)
                if gt(searchLength, mload(subject)) { break }
                let w := result

                let fromMax := sub(mload(subject), searchLength)
                if iszero(gt(fromMax, from)) { from := fromMax }

                let end := add(add(subject, 0x20), w)
                subject := add(add(subject, 0x20), from)
                if iszero(gt(subject, end)) { break }
                // As this function is not too often used,
                // we shall simply use keccak256 for smaller bytecode size.
                for { let h := keccak256(add(search, 0x20), searchLength) } 1 {} {
                    if eq(keccak256(subject, searchLength), h) {
                        result := sub(subject, add(end, 1))
                        break
                    }
                    subject := add(subject, w) // `sub(subject, 1)`.
                    if iszero(gt(subject, end)) { break }
                }
                break
            }
        }
    }

    /// @dev Returns the byte index of the first location of `search` in `subject`,
    /// searching from right to left.
    /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found.
    function lastIndexOf(string memory subject, string memory search)
        internal
        pure
        returns (uint256 result)
    {
        result = lastIndexOf(subject, search, uint256(int256(-1)));
    }

    /// @dev Returns whether `subject` starts with `search`.
    function startsWith(string memory subject, string memory search)
        internal
        pure
        returns (bool result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let searchLength := mload(search)
            // Just using keccak256 directly is actually cheaper.
            // forgefmt: disable-next-item
            result := and(
                iszero(gt(searchLength, mload(subject))),
                eq(
                    keccak256(add(subject, 0x20), searchLength),
                    keccak256(add(search, 0x20), searchLength)
                )
            )
        }
    }

    /// @dev Returns whether `subject` ends with `search`.
    function endsWith(string memory subject, string memory search)
        internal
        pure
        returns (bool result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let searchLength := mload(search)
            let subjectLength := mload(subject)
            // Whether `search` is not longer than `subject`.
            let withinRange := iszero(gt(searchLength, subjectLength))
            // Just using keccak256 directly is actually cheaper.
            // forgefmt: disable-next-item
            result := and(
                withinRange,
                eq(
                    keccak256(
                        // `subject + 0x20 + max(subjectLength - searchLength, 0)`.
                        add(add(subject, 0x20), mul(withinRange, sub(subjectLength, searchLength))),
                        searchLength
                    ),
                    keccak256(add(search, 0x20), searchLength)
                )
            )
        }
    }

    /// @dev Returns `subject` repeated `times`.
    function repeat(string memory subject, uint256 times)
        internal
        pure
        returns (string memory result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let subjectLength := mload(subject)
            if iszero(or(iszero(times), iszero(subjectLength))) {
                subject := add(subject, 0x20)
                result := mload(0x40)
                let output := add(result, 0x20)
                for {} 1 {} {
                    // Copy the `subject` one word at a time.
                    for { let o := 0 } 1 {} {
                        mstore(add(output, o), mload(add(subject, o)))
                        o := add(o, 0x20)
                        if iszero(lt(o, subjectLength)) { break }
                    }
                    output := add(output, subjectLength)
                    times := sub(times, 1)
                    if iszero(times) { break }
                }
                mstore(output, 0) // Zeroize the slot after the string.
                let resultLength := sub(output, add(result, 0x20))
                mstore(result, resultLength) // Store the length.
                // Allocate the memory.
                mstore(0x40, add(result, add(resultLength, 0x20)))
            }
        }
    }

    /// @dev Returns a copy of `subject` sliced from `start` to `end` (exclusive).
    /// `start` and `end` are byte offsets.
    function slice(string memory subject, uint256 start, uint256 end)
        internal
        pure
        returns (string memory result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let subjectLength := mload(subject)
            if iszero(gt(subjectLength, end)) { end := subjectLength }
            if iszero(gt(subjectLength, start)) { start := subjectLength }
            if lt(start, end) {
                result := mload(0x40)
                let resultLength := sub(end, start)
                mstore(result, resultLength)
                subject := add(subject, start)
                let w := not(0x1f)
                // Copy the `subject` one word at a time, backwards.
                for { let o := and(add(resultLength, 0x1f), w) } 1 {} {
                    mstore(add(result, o), mload(add(subject, o)))
                    o := add(o, w) // `sub(o, 0x20)`.
                    if iszero(o) { break }
                }
                // Zeroize the slot after the string.
                mstore(add(add(result, 0x20), resultLength), 0)
                // Allocate memory for the length and the bytes,
                // rounded up to a multiple of 32.
                mstore(0x40, add(result, and(add(resultLength, 0x3f), w)))
            }
        }
    }

    /// @dev Returns a copy of `subject` sliced from `start` to the end of the string.
    /// `start` is a byte offset.
    function slice(string memory subject, uint256 start)
        internal
        pure
        returns (string memory result)
    {
        result = slice(subject, start, uint256(int256(-1)));
    }

    /// @dev Returns all the indices of `search` in `subject`.
    /// The indices are byte offsets.
    function indicesOf(string memory subject, string memory search)
        internal
        pure
        returns (uint256[] memory result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let subjectLength := mload(subject)
            let searchLength := mload(search)

            if iszero(gt(searchLength, subjectLength)) {
                subject := add(subject, 0x20)
                search := add(search, 0x20)
                result := add(mload(0x40), 0x20)

                let subjectStart := subject
                let subjectSearchEnd := add(sub(add(subject, subjectLength), searchLength), 1)
                let h := 0
                if iszero(lt(searchLength, 0x20)) { h := keccak256(search, searchLength) }
                let m := shl(3, sub(0x20, and(searchLength, 0x1f)))
                let s := mload(search)
                for {} 1 {} {
                    let t := mload(subject)
                    // Whether the first `searchLength % 32` bytes of
                    // `subject` and `search` matches.
                    if iszero(shr(m, xor(t, s))) {
                        if h {
                            if iszero(eq(keccak256(subject, searchLength), h)) {
                                subject := add(subject, 1)
                                if iszero(lt(subject, subjectSearchEnd)) { break }
                                continue
                            }
                        }
                        // Append to `result`.
                        mstore(result, sub(subject, subjectStart))
                        result := add(result, 0x20)
                        // Advance `subject` by `searchLength`.
                        subject := add(subject, searchLength)
                        if searchLength {
                            if iszero(lt(subject, subjectSearchEnd)) { break }
                            continue
                        }
                    }
                    subject := add(subject, 1)
                    if iszero(lt(subject, subjectSearchEnd)) { break }
                }
                let resultEnd := result
                // Assign `result` to the free memory pointer.
                result := mload(0x40)
                // Store the length of `result`.
                mstore(result, shr(5, sub(resultEnd, add(result, 0x20))))
                // Allocate memory for result.
                // We allocate one more word, so this array can be recycled for {split}.
                mstore(0x40, add(resultEnd, 0x20))
            }
        }
    }

    /// @dev Returns a arrays of strings based on the `delimiter` inside of the `subject` string.
    function split(string memory subject, string memory delimiter)
        internal
        pure
        returns (string[] memory result)
    {
        uint256[] memory indices = indicesOf(subject, delimiter);
        /// @solidity memory-safe-assembly
        assembly {
            let w := not(0x1f)
            let indexPtr := add(indices, 0x20)
            let indicesEnd := add(indexPtr, shl(5, add(mload(indices), 1)))
            mstore(add(indicesEnd, w), mload(subject))
            mstore(indices, add(mload(indices), 1))
            let prevIndex := 0
            for {} 1 {} {
                let index := mload(indexPtr)
                mstore(indexPtr, 0x60)
                if iszero(eq(index, prevIndex)) {
                    let element := mload(0x40)
                    let elementLength := sub(index, prevIndex)
                    mstore(element, elementLength)
                    // Copy the `subject` one word at a time, backwards.
                    for { let o := and(add(elementLength, 0x1f), w) } 1 {} {
                        mstore(add(element, o), mload(add(add(subject, prevIndex), o)))
                        o := add(o, w) // `sub(o, 0x20)`.
                        if iszero(o) { break }
                    }
                    // Zeroize the slot after the string.
                    mstore(add(add(element, 0x20), elementLength), 0)
                    // Allocate memory for the length and the bytes,
                    // rounded up to a multiple of 32.
                    mstore(0x40, add(element, and(add(elementLength, 0x3f), w)))
                    // Store the `element` into the array.
                    mstore(indexPtr, element)
                }
                prevIndex := add(index, mload(delimiter))
                indexPtr := add(indexPtr, 0x20)
                if iszero(lt(indexPtr, indicesEnd)) { break }
            }
            result := indices
            if iszero(mload(delimiter)) {
                result := add(indices, 0x20)
                mstore(result, sub(mload(indices), 2))
            }
        }
    }

    /// @dev Returns a concatenated string of `a` and `b`.
    /// Cheaper than `string.concat()` and does not de-align the free memory pointer.
    function concat(string memory a, string memory b)
        internal
        pure
        returns (string memory result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let w := not(0x1f)
            result := mload(0x40)
            let aLength := mload(a)
            // Copy `a` one word at a time, backwards.
            for { let o := and(add(mload(a), 0x20), w) } 1 {} {
                mstore(add(result, o), mload(add(a, o)))
                o := add(o, w) // `sub(o, 0x20)`.
                if iszero(o) { break }
            }
            let bLength := mload(b)
            let output := add(result, mload(a))
            // Copy `b` one word at a time, backwards.
            for { let o := and(add(bLength, 0x20), w) } 1 {} {
                mstore(add(output, o), mload(add(b, o)))
                o := add(o, w) // `sub(o, 0x20)`.
                if iszero(o) { break }
            }
            let totalLength := add(aLength, bLength)
            let last := add(add(result, 0x20), totalLength)
            // Zeroize the slot after the string.
            mstore(last, 0)
            // Stores the length.
            mstore(result, totalLength)
            // Allocate memory for the length and the bytes,
            // rounded up to a multiple of 32.
            mstore(0x40, and(add(last, 0x1f), w))
        }
    }

    /// @dev Returns a copy of the string in either lowercase or UPPERCASE.
    /// WARNING! This function is only compatible with 7-bit ASCII strings.
    function toCase(string memory subject, bool toUpper)
        internal
        pure
        returns (string memory result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let length := mload(subject)
            if length {
                result := add(mload(0x40), 0x20)
                subject := add(subject, 1)
                let flags := shl(add(70, shl(5, toUpper)), 0x3ffffff)
                let w := not(0)
                for { let o := length } 1 {} {
                    o := add(o, w)
                    let b := and(0xff, mload(add(subject, o)))
                    mstore8(add(result, o), xor(b, and(shr(b, flags), 0x20)))
                    if iszero(o) { break }
                }
                result := mload(0x40)
                mstore(result, length) // Store the length.
                let last := add(add(result, 0x20), length)
                mstore(last, 0) // Zeroize the slot after the string.
                mstore(0x40, add(last, 0x20)) // Allocate the memory.
            }
        }
    }

    /// @dev Returns a lowercased copy of the string.
    /// WARNING! This function is only compatible with 7-bit ASCII strings.
    function lower(string memory subject) internal pure returns (string memory result) {
        result = toCase(subject, false);
    }

    /// @dev Returns an UPPERCASED copy of the string.
    /// WARNING! This function is only compatible with 7-bit ASCII strings.
    function upper(string memory subject) internal pure returns (string memory result) {
        result = toCase(subject, true);
    }

    /// @dev Escapes the string to be used within HTML tags.
    function escapeHTML(string memory s) internal pure returns (string memory result) {
        /// @solidity memory-safe-assembly
        assembly {
            for {
                let end := add(s, mload(s))
                result := add(mload(0x40), 0x20)
                // Store the bytes of the packed offsets and strides into the scratch space.
                // `packed = (stride << 5) | offset`. Max offset is 20. Max stride is 6.
                mstore(0x1f, 0x900094)
                mstore(0x08, 0xc0000000a6ab)
                // Store "&quot;&amp;&#39;&lt;&gt;" into the scratch space.
                mstore(0x00, shl(64, 0x2671756f743b26616d703b262333393b266c743b2667743b))
            } iszero(eq(s, end)) {} {
                s := add(s, 1)
                let c := and(mload(s), 0xff)
                // Not in `["\"","'","&","<",">"]`.
                if iszero(and(shl(c, 1), 0x500000c400000000)) {
                    mstore8(result, c)
                    result := add(result, 1)
                    continue
                }
                let t := shr(248, mload(c))
                mstore(result, mload(and(t, 0x1f)))
                result := add(result, shr(5, t))
            }
            let last := result
            mstore(last, 0) // Zeroize the slot after the string.
            result := mload(0x40)
            mstore(result, sub(last, add(result, 0x20))) // Store the length.
            mstore(0x40, add(last, 0x20)) // Allocate the memory.
        }
    }

    /// @dev Escapes the string to be used within double-quotes in a JSON.
    function escapeJSON(string memory s) internal pure returns (string memory result) {
        /// @solidity memory-safe-assembly
        assembly {
            for {
                let end := add(s, mload(s))
                result := add(mload(0x40), 0x20)
                // Store "\\u0000" in scratch space.
                // Store "0123456789abcdef" in scratch space.
                // Also, store `{0x08:"b", 0x09:"t", 0x0a:"n", 0x0c:"f", 0x0d:"r"}`.
                // into the scratch space.
                mstore(0x15, 0x5c75303030303031323334353637383961626364656662746e006672)
                // Bitmask for detecting `["\"","\\"]`.
                let e := or(shl(0x22, 1), shl(0x5c, 1))
            } iszero(eq(s, end)) {} {
                s := add(s, 1)
                let c := and(mload(s), 0xff)
                if iszero(lt(c, 0x20)) {
                    if iszero(and(shl(c, 1), e)) {
                        // Not in `["\"","\\"]`.
                        mstore8(result, c)
                        result := add(result, 1)
                        continue
                    }
                    mstore8(result, 0x5c) // "\\".
                    mstore8(add(result, 1), c)
                    result := add(result, 2)
                    continue
                }
                if iszero(and(shl(c, 1), 0x3700)) {
                    // Not in `["\b","\t","\n","\f","\d"]`.
                    mstore8(0x1d, mload(shr(4, c))) // Hex value.
                    mstore8(0x1e, mload(and(c, 15))) // Hex value.
                    mstore(result, mload(0x19)) // "\\u00XX".
                    result := add(result, 6)
                    continue
                }
                mstore8(result, 0x5c) // "\\".
                mstore8(add(result, 1), mload(add(c, 8)))
                result := add(result, 2)
            }
            let last := result
            mstore(last, 0) // Zeroize the slot after the string.
            result := mload(0x40)
            mstore(result, sub(last, add(result, 0x20))) // Store the length.
            mstore(0x40, add(last, 0x20)) // Allocate the memory.
        }
    }

    /// @dev Returns whether `a` equals `b`.
    function eq(string memory a, string memory b) internal pure returns (bool result) {
        assembly {
            result := eq(keccak256(add(a, 0x20), mload(a)), keccak256(add(b, 0x20), mload(b)))
        }
    }

    /// @dev Packs a single string with its length into a single word.
    /// Returns `bytes32(0)` if the length is zero or greater than 31.
    function packOne(string memory a) internal pure returns (bytes32 result) {
        /// @solidity memory-safe-assembly
        assembly {
            // We don't need to zero right pad the string,
            // since this is our own custom non-standard packing scheme.
            result :=
                mul(
                    // Load the length and the bytes.
                    mload(add(a, 0x1f)),
                    // `length != 0 && length < 32`. Abuses underflow.
                    // Assumes that the length is valid and within the block gas limit.
                    lt(sub(mload(a), 1), 0x1f)
                )
        }
    }

    /// @dev Unpacks a string packed using {packOne}.
    /// Returns the empty string if `packed` is `bytes32(0)`.
    /// If `packed` is not an output of {packOne}, the output behaviour is undefined.
    function unpackOne(bytes32 packed) internal pure returns (string memory result) {
        /// @solidity memory-safe-assembly
        assembly {
            // Grab the free memory pointer.
            result := mload(0x40)
            // Allocate 2 words (1 for the length, 1 for the bytes).
            mstore(0x40, add(result, 0x40))
            // Zeroize the length slot.
            mstore(result, 0)
            // Store the length and bytes.
            mstore(add(result, 0x1f), packed)
            // Right pad with zeroes.
            mstore(add(add(result, 0x20), mload(result)), 0)
        }
    }

    /// @dev Packs two strings with their lengths into a single word.
    /// Returns `bytes32(0)` if combined length is zero or greater than 30.
    function packTwo(string memory a, string memory b) internal pure returns (bytes32 result) {
        /// @solidity memory-safe-assembly
        assembly {
            let aLength := mload(a)
            // We don't need to zero right pad the strings,
            // since this is our own custom non-standard packing scheme.
            result :=
                mul(
                    // Load the length and the bytes of `a` and `b`.
                    or(
                        shl(shl(3, sub(0x1f, aLength)), mload(add(a, aLength))),
                        mload(sub(add(b, 0x1e), aLength))
                    ),
                    // `totalLength != 0 && totalLength < 31`. Abuses underflow.
                    // Assumes that the lengths are valid and within the block gas limit.
                    lt(sub(add(aLength, mload(b)), 1), 0x1e)
                )
        }
    }

    /// @dev Unpacks strings packed using {packTwo}.
    /// Returns the empty strings if `packed` is `bytes32(0)`.
    /// If `packed` is not an output of {packTwo}, the output behaviour is undefined.
    function unpackTwo(bytes32 packed)
        internal
        pure
        returns (string memory resultA, string memory resultB)
    {
        /// @solidity memory-safe-assembly
        assembly {
            // Grab the free memory pointer.
            resultA := mload(0x40)
            resultB := add(resultA, 0x40)
            // Allocate 2 words for each string (1 for the length, 1 for the byte). Total 4 words.
            mstore(0x40, add(resultB, 0x40))
            // Zeroize the length slots.
            mstore(resultA, 0)
            mstore(resultB, 0)
            // Store the lengths and bytes.
            mstore(add(resultA, 0x1f), packed)
            mstore(add(resultB, 0x1f), mload(add(add(resultA, 0x20), mload(resultA))))
            // Right pad with zeroes.
            mstore(add(add(resultA, 0x20), mload(resultA)), 0)
            mstore(add(add(resultB, 0x20), mload(resultB)), 0)
        }
    }

    /// @dev Directly returns `a` without copying.
    function directReturn(string memory a) internal pure {
        assembly {
            // Assumes that the string does not start from the scratch space.
            let retStart := sub(a, 0x20)
            let retSize := add(mload(a), 0x40)
            // Right pad with zeroes. Just in case the string is produced
            // by a method that doesn't zero right pad.
            mstore(add(retStart, retSize), 0)
            // Store the return offset.
            mstore(retStart, 0x20)
            // End the transaction, returning the string.
            return(retStart, retSize)
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

/// @notice Read and write to persistent storage at a fraction of the cost.
/// @author Solady (https://github.com/vectorized/solmady/blob/main/src/utils/SSTORE2.sol)
/// @author Saw-mon-and-Natalie (https://github.com/Saw-mon-and-Natalie)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SSTORE2.sol)
/// @author Modified from 0xSequence (https://github.com/0xSequence/sstore2/blob/master/contracts/SSTORE2.sol)
library SSTORE2 {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         CONSTANTS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev We skip the first byte as it's a STOP opcode,
    /// which ensures the contract can't be called.
    uint256 internal constant DATA_OFFSET = 1;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                        CUSTOM ERRORS                       */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Unable to deploy the storage contract.
    error DeploymentFailed();

    /// @dev The storage contract address is invalid.
    error InvalidPointer();

    /// @dev Attempt to read outside of the storage contract's bytecode bounds.
    error ReadOutOfBounds();

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         WRITE LOGIC                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Writes `data` into the bytecode of a storage contract and returns its address.
    function write(bytes memory data) internal returns (address pointer) {
        /// @solidity memory-safe-assembly
        assembly {
            let originalDataLength := mload(data)

            // Add 1 to data size since we are prefixing it with a STOP opcode.
            let dataSize := add(originalDataLength, DATA_OFFSET)

            /**
             * ------------------------------------------------------------------------------+
             * Opcode      | Mnemonic        | Stack                   | Memory              |
             * ------------------------------------------------------------------------------|
             * 61 codeSize | PUSH2 codeSize  | codeSize                |                     |
             * 80          | DUP1            | codeSize codeSize       |                     |
             * 60 0xa      | PUSH1 0xa       | 0xa codeSize codeSize   |                     |
             * 3D          | RETURNDATASIZE  | 0 0xa codeSize codeSize |                     |
             * 39          | CODECOPY        | codeSize                | [0..codeSize): code |
             * 3D          | RETURNDATASIZE  | 0 codeSize              | [0..codeSize): code |
             * F3          | RETURN          |                         | [0..codeSize): code |
             * 00          | STOP            |                         |                     |
             * ------------------------------------------------------------------------------+
             * @dev Prefix the bytecode with a STOP opcode to ensure it cannot be called.
             * Also PUSH2 is used since max contract size cap is 24,576 bytes which is less than 2 ** 16.
             */
            mstore(
                data,
                or(
                    0x61000080600a3d393df300,
                    // Left shift `dataSize` by 64 so that it lines up with the 0000 after PUSH2.
                    shl(0x40, dataSize)
                )
            )

            // Deploy a new contract with the generated creation code.
            pointer := create(0, add(data, 0x15), add(dataSize, 0xa))

            // If `pointer` is zero, revert.
            if iszero(pointer) {
                // Store the function selector of `DeploymentFailed()`.
                mstore(0x00, 0x30116425)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }

            // Restore original length of the variable size `data`.
            mstore(data, originalDataLength)
        }
    }

    /// @dev Writes `data` into the bytecode of a storage contract with `salt`
    /// and returns its deterministic address.
    function writeDeterministic(bytes memory data, bytes32 salt)
        internal
        returns (address pointer)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let originalDataLength := mload(data)
            let dataSize := add(originalDataLength, DATA_OFFSET)

            mstore(data, or(0x61000080600a3d393df300, shl(0x40, dataSize)))

            // Deploy a new contract with the generated creation code.
            pointer := create2(0, add(data, 0x15), add(dataSize, 0xa), salt)

            // If `pointer` is zero, revert.
            if iszero(pointer) {
                // Store the function selector of `DeploymentFailed()`.
                mstore(0x00, 0x30116425)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }

            // Restore original length of the variable size `data`.
            mstore(data, originalDataLength)
        }
    }

    /// @dev Returns the initialization code hash of the storage contract for `data`.
    /// Used for mining vanity addresses with create2crunch.
    function initCodeHash(bytes memory data) internal pure returns (bytes32 hash) {
        /// @solidity memory-safe-assembly
        assembly {
            let originalDataLength := mload(data)
            let dataSize := add(originalDataLength, DATA_OFFSET)

            mstore(data, or(0x61000080600a3d393df300, shl(0x40, dataSize)))

            hash := keccak256(add(data, 0x15), add(dataSize, 0xa))

            // Restore original length of the variable size `data`.
            mstore(data, originalDataLength)
        }
    }

    /// @dev Returns the address of the storage contract for `data`
    /// deployed with `salt` by `deployer`.
    function predictDeterministicAddress(bytes memory data, bytes32 salt, address deployer)
        internal
        pure
        returns (address predicted)
    {
        bytes32 hash = initCodeHash(data);
        /// @solidity memory-safe-assembly
        assembly {
            // Compute and store the bytecode hash.
            mstore8(0x00, 0xff) // Write the prefix.
            mstore(0x35, hash)
            mstore(0x01, shl(96, deployer))
            mstore(0x15, salt)
            predicted := keccak256(0x00, 0x55)
            // Restore the part of the free memory pointer that has been overwritten.
            mstore(0x35, 0)
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         READ LOGIC                         */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns all the `data` from the bytecode of the storage contract at `pointer`.
    function read(address pointer) internal view returns (bytes memory data) {
        /// @solidity memory-safe-assembly
        assembly {
            let pointerCodesize := extcodesize(pointer)
            if iszero(pointerCodesize) {
                // Store the function selector of `InvalidPointer()`.
                mstore(0x00, 0x11052bb4)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
            // Offset all indices by 1 to skip the STOP opcode.
            let size := sub(pointerCodesize, DATA_OFFSET)

            // Get the pointer to the free memory and allocate
            // enough 32-byte words for the data and the length of the data,
            // then copy the code to the allocated memory.
            // Masking with 0xffe0 will suffice, since contract size is less than 16 bits.
            data := mload(0x40)
            mstore(0x40, add(data, and(add(size, 0x3f), 0xffe0)))
            mstore(data, size)
            mstore(add(add(data, 0x20), size), 0) // Zeroize the last slot.
            extcodecopy(pointer, add(data, 0x20), DATA_OFFSET, size)
        }
    }

    /// @dev Returns the `data` from the bytecode of the storage contract at `pointer`,
    /// from the byte at `start`, to the end of the data stored.
    function read(address pointer, uint256 start) internal view returns (bytes memory data) {
        /// @solidity memory-safe-assembly
        assembly {
            let pointerCodesize := extcodesize(pointer)
            if iszero(pointerCodesize) {
                // Store the function selector of `InvalidPointer()`.
                mstore(0x00, 0x11052bb4)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }

            // If `!(pointer.code.size > start)`, reverts.
            // This also handles the case where `start + DATA_OFFSET` overflows.
            if iszero(gt(pointerCodesize, start)) {
                // Store the function selector of `ReadOutOfBounds()`.
                mstore(0x00, 0x84eb0dd1)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
            let size := sub(pointerCodesize, add(start, DATA_OFFSET))

            // Get the pointer to the free memory and allocate
            // enough 32-byte words for the data and the length of the data,
            // then copy the code to the allocated memory.
            // Masking with 0xffe0 will suffice, since contract size is less than 16 bits.
            data := mload(0x40)
            mstore(0x40, add(data, and(add(size, 0x3f), 0xffe0)))
            mstore(data, size)
            mstore(add(add(data, 0x20), size), 0) // Zeroize the last slot.
            extcodecopy(pointer, add(data, 0x20), add(start, DATA_OFFSET), size)
        }
    }

    /// @dev Returns the `data` from the bytecode of the storage contract at `pointer`,
    /// from the byte at `start`, to the byte at `end` (exclusive) of the data stored.
    function read(address pointer, uint256 start, uint256 end)
        internal
        view
        returns (bytes memory data)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let pointerCodesize := extcodesize(pointer)
            if iszero(pointerCodesize) {
                // Store the function selector of `InvalidPointer()`.
                mstore(0x00, 0x11052bb4)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }

            // If `!(pointer.code.size > end) || (start > end)`, revert.
            // This also handles the cases where
            // `end + DATA_OFFSET` or `start + DATA_OFFSET` overflows.
            if iszero(
                and(
                    gt(pointerCodesize, end), // Within bounds.
                    iszero(gt(start, end)) // Valid range.
                )
            ) {
                // Store the function selector of `ReadOutOfBounds()`.
                mstore(0x00, 0x84eb0dd1)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
            let size := sub(end, start)

            // Get the pointer to the free memory and allocate
            // enough 32-byte words for the data and the length of the data,
            // then copy the code to the allocated memory.
            // Masking with 0xffe0 will suffice, since contract size is less than 16 bits.
            data := mload(0x40)
            mstore(0x40, add(data, and(add(size, 0x3f), 0xffe0)))
            mstore(data, size)
            mstore(add(add(data, 0x20), size), 0) // Zeroize the last slot.
            extcodecopy(pointer, add(data, 0x20), add(start, DATA_OFFSET), size)
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/SafeTransferLib.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SafeTransferLib.sol)
/// @dev Caution! This library won't check that a token has code, responsibility is delegated to the caller.
library SafeTransferLib {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The ETH transfer has failed.
    error ETHTransferFailed();

    /// @dev The ERC20 `transferFrom` has failed.
    error TransferFromFailed();

    /// @dev The ERC20 `transfer` has failed.
    error TransferFailed();

    /// @dev The ERC20 `approve` has failed.
    error ApproveFailed();

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         CONSTANTS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Suggested gas stipend for contract receiving ETH
    /// that disallows any storage writes.
    uint256 internal constant _GAS_STIPEND_NO_STORAGE_WRITES = 2300;

    /// @dev Suggested gas stipend for contract receiving ETH to perform a few
    /// storage reads and writes, but low enough to prevent griefing.
    /// Multiply by a small constant (e.g. 2), if needed.
    uint256 internal constant _GAS_STIPEND_NO_GRIEF = 100000;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       ETH OPERATIONS                       */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Sends `amount` (in wei) ETH to `to`.
    /// Reverts upon failure.
    function safeTransferETH(address to, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            // Transfer the ETH and check if it succeeded or not.
            if iszero(call(gas(), to, amount, 0, 0, 0, 0)) {
                // Store the function selector of `ETHTransferFailed()`.
                mstore(0x00, 0xb12d13eb)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
        }
    }

    /// @dev Force sends `amount` (in wei) ETH to `to`, with a `gasStipend`.
    /// The `gasStipend` can be set to a low enough value to prevent
    /// storage writes or gas griefing.
    ///
    /// If sending via the normal procedure fails, force sends the ETH by
    /// creating a temporary contract which uses `SELFDESTRUCT` to force send the ETH.
    ///
    /// Reverts if the current contract has insufficient balance.
    function forceSafeTransferETH(address to, uint256 amount, uint256 gasStipend) internal {
        /// @solidity memory-safe-assembly
        assembly {
            // If insufficient balance, revert.
            if lt(selfbalance(), amount) {
                // Store the function selector of `ETHTransferFailed()`.
                mstore(0x00, 0xb12d13eb)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
            // Transfer the ETH and check if it succeeded or not.
            if iszero(call(gasStipend, to, amount, 0, 0, 0, 0)) {
                mstore(0x00, to) // Store the address in scratch space.
                mstore8(0x0b, 0x73) // Opcode `PUSH20`.
                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.
                // We can directly use `SELFDESTRUCT` in the contract creation.
                // Compatible with `SENDALL`: https://eips.ethereum.org/EIPS/eip-4758
                if iszero(create(amount, 0x0b, 0x16)) {
                    // For better gas estimation.
                    if iszero(gt(gas(), 1000000)) { revert(0, 0) }
                }
            }
        }
    }

    /// @dev Force sends `amount` (in wei) ETH to `to`, with a gas stipend
    /// equal to `_GAS_STIPEND_NO_GRIEF`. This gas stipend is a reasonable default
    /// for 99% of cases and can be overriden with the three-argument version of this
    /// function if necessary.
    ///
    /// If sending via the normal procedure fails, force sends the ETH by
    /// creating a temporary contract which uses `SELFDESTRUCT` to force send the ETH.
    ///
    /// Reverts if the current contract has insufficient balance.
    function forceSafeTransferETH(address to, uint256 amount) internal {
        // Manually inlined because the compiler doesn't inline functions with branches.
        /// @solidity memory-safe-assembly
        assembly {
            // If insufficient balance, revert.
            if lt(selfbalance(), amount) {
                // Store the function selector of `ETHTransferFailed()`.
                mstore(0x00, 0xb12d13eb)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
            // Transfer the ETH and check if it succeeded or not.
            if iszero(call(_GAS_STIPEND_NO_GRIEF, to, amount, 0, 0, 0, 0)) {
                mstore(0x00, to) // Store the address in scratch space.
                mstore8(0x0b, 0x73) // Opcode `PUSH20`.
                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.
                // We can directly use `SELFDESTRUCT` in the contract creation.
                // Compatible with `SENDALL`: https://eips.ethereum.org/EIPS/eip-4758
                if iszero(create(amount, 0x0b, 0x16)) {
                    // For better gas estimation.
                    if iszero(gt(gas(), 1000000)) { revert(0, 0) }
                }
            }
        }
    }

    /// @dev Sends `amount` (in wei) ETH to `to`, with a `gasStipend`.
    /// The `gasStipend` can be set to a low enough value to prevent
    /// storage writes or gas griefing.
    ///
    /// Simply use `gasleft()` for `gasStipend` if you don't need a gas stipend.
    ///
    /// Note: Does NOT revert upon failure.
    /// Returns whether the transfer of ETH is successful instead.
    function trySafeTransferETH(address to, uint256 amount, uint256 gasStipend)
        internal
        returns (bool success)
    {
        /// @solidity memory-safe-assembly
        assembly {
            // Transfer the ETH and check if it succeeded or not.
            success := call(gasStipend, to, amount, 0, 0, 0, 0)
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                      ERC20 OPERATIONS                      */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Sends `amount` of ERC20 `token` from `from` to `to`.
    /// Reverts upon failure.
    ///
    /// The `from` account must have at least `amount` approved for
    /// the current contract to manage.
    function safeTransferFrom(address token, address from, address to, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            let m := mload(0x40) // Cache the free memory pointer.

            mstore(0x60, amount) // Store the `amount` argument.
            mstore(0x40, to) // Store the `to` argument.
            mstore(0x2c, shl(96, from)) // Store the `from` argument.
            // Store the function selector of `transferFrom(address,address,uint256)`.
            mstore(0x0c, 0x23b872dd000000000000000000000000)

            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    // Set success to whether the call reverted, if not we check it either
                    // returned exactly 1 (can't just be non-zero data), or had no return data.
                    or(eq(mload(0x00), 1), iszero(returndatasize())),
                    call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
                )
            ) {
                // Store the function selector of `TransferFromFailed()`.
                mstore(0x00, 0x7939f424)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }

            mstore(0x60, 0) // Restore the zero slot to zero.
            mstore(0x40, m) // Restore the free memory pointer.
        }
    }

    /// @dev Sends all of ERC20 `token` from `from` to `to`.
    /// Reverts upon failure.
    ///
    /// The `from` account must have at least `amount` approved for
    /// the current contract to manage.
    function safeTransferAllFrom(address token, address from, address to)
        internal
        returns (uint256 amount)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let m := mload(0x40) // Cache the free memory pointer.

            mstore(0x40, to) // Store the `to` argument.
            mstore(0x2c, shl(96, from)) // Store the `from` argument.
            // Store the function selector of `balanceOf(address)`.
            mstore(0x0c, 0x70a08231000000000000000000000000)
            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    gt(returndatasize(), 0x1f), // At least 32 bytes returned.
                    staticcall(gas(), token, 0x1c, 0x24, 0x60, 0x20)
                )
            ) {
                // Store the function selector of `TransferFromFailed()`.
                mstore(0x00, 0x7939f424)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }

            // Store the function selector of `transferFrom(address,address,uint256)`.
            mstore(0x00, 0x23b872dd)
            // The `amount` argument is already written to the memory word at 0x6c.
            amount := mload(0x60)

            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    // Set success to whether the call reverted, if not we check it either
                    // returned exactly 1 (can't just be non-zero data), or had no return data.
                    or(eq(mload(0x00), 1), iszero(returndatasize())),
                    call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
                )
            ) {
                // Store the function selector of `TransferFromFailed()`.
                mstore(0x00, 0x7939f424)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }

            mstore(0x60, 0) // Restore the zero slot to zero.
            mstore(0x40, m) // Restore the free memory pointer.
        }
    }

    /// @dev Sends `amount` of ERC20 `token` from the current contract to `to`.
    /// Reverts upon failure.
    function safeTransfer(address token, address to, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x14, to) // Store the `to` argument.
            mstore(0x34, amount) // Store the `amount` argument.
            // Store the function selector of `transfer(address,uint256)`.
            mstore(0x00, 0xa9059cbb000000000000000000000000)

            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    // Set success to whether the call reverted, if not we check it either
                    // returned exactly 1 (can't just be non-zero data), or had no return data.
                    or(eq(mload(0x00), 1), iszero(returndatasize())),
                    call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
                )
            ) {
                // Store the function selector of `TransferFailed()`.
                mstore(0x00, 0x90b8ec18)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
            // Restore the part of the free memory pointer that was overwritten.
            mstore(0x34, 0)
        }
    }

    /// @dev Sends all of ERC20 `token` from the current contract to `to`.
    /// Reverts upon failure.
    function safeTransferAll(address token, address to) internal returns (uint256 amount) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, 0x70a08231) // Store the function selector of `balanceOf(address)`.
            mstore(0x20, address()) // Store the address of the current contract.
            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    gt(returndatasize(), 0x1f), // At least 32 bytes returned.
                    staticcall(gas(), token, 0x1c, 0x24, 0x34, 0x20)
                )
            ) {
                // Store the function selector of `TransferFailed()`.
                mstore(0x00, 0x90b8ec18)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }

            mstore(0x14, to) // Store the `to` argument.
            // The `amount` argument is already written to the memory word at 0x34.
            amount := mload(0x34)
            // Store the function selector of `transfer(address,uint256)`.
            mstore(0x00, 0xa9059cbb000000000000000000000000)

            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    // Set success to whether the call reverted, if not we check it either
                    // returned exactly 1 (can't just be non-zero data), or had no return data.
                    or(eq(mload(0x00), 1), iszero(returndatasize())),
                    call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
                )
            ) {
                // Store the function selector of `TransferFailed()`.
                mstore(0x00, 0x90b8ec18)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
            // Restore the part of the free memory pointer that was overwritten.
            mstore(0x34, 0)
        }
    }

    /// @dev Sets `amount` of ERC20 `token` for `to` to manage on behalf of the current contract.
    /// Reverts upon failure.
    function safeApprove(address token, address to, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x14, to) // Store the `to` argument.
            mstore(0x34, amount) // Store the `amount` argument.
            // Store the function selector of `approve(address,uint256)`.
            mstore(0x00, 0x095ea7b3000000000000000000000000)

            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    // Set success to whether the call reverted, if not we check it either
                    // returned exactly 1 (can't just be non-zero data), or had no return data.
                    or(eq(mload(0x00), 1), iszero(returndatasize())),
                    call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
                )
            ) {
                // Store the function selector of `ApproveFailed()`.
                mstore(0x00, 0x3e3f8f73)
                // Revert with (offset, size).
                revert(0x1c, 0x04)
            }
            // Restore the part of the free memory pointer that was overwritten.
            mstore(0x34, 0)
        }
    }

    /// @dev Returns the amount of ERC20 `token` owned by `account`.
    /// Returns zero if the `token` does not exist.
    function balanceOf(address token, address account) internal view returns (uint256 amount) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x14, account) // Store the `account` argument.
            // Store the function selector of `balanceOf(address)`.
            mstore(0x00, 0x70a08231000000000000000000000000)
            amount :=
                mul(
                    mload(0x20),
                    and( // The arguments of `and` are evaluated from right to left.
                        gt(returndatasize(), 0x1f), // At least 32 bytes returned.
                        staticcall(gas(), token, 0x10, 0x24, 0x20, 0x20)
                    )
                )
        }
    }
}

{
  "evmVersion": "london",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs",
    "useLiteralContent": true
  },
  "optimizer": {
    "details": {
      "constantOptimizer": true,
      "cse": true,
      "deduplicate": true,
      "inliner": true,
      "jumpdestRemover": true,
      "orderLiterals": true,
      "peephole": true,
      "yul": false
    },
    "runs": 200
  },
  "remappings": [],
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"components":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"nameSingular","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"string","name":"externalLink","type":"string"},{"internalType":"string","name":"tokenDescription","type":"string"},{"internalType":"uint256","name":"costPerToken","type":"uint256"},{"internalType":"uint16","name":"maxSupply","type":"uint16"},{"internalType":"uint16","name":"remainingSupply","type":"uint16"},{"internalType":"uint8","name":"remainingKeyMints","type":"uint8"},{"internalType":"bool","name":"operatorFilteringEnabled","type":"bool"},{"internalType":"bool","name":"isMintActive","type":"bool"},{"internalType":"bool","name":"contractSealed","type":"bool"}],"internalType":"struct Drunks.ContractConfig","name":"_config","type":"tuple"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AccountBalanceOverflow","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"ContractSealed","type":"error"},{"inputs":[],"name":"ContractsCannotMint","type":"error"},{"inputs":[],"name":"MintIsNotActive","type":"error"},{"inputs":[],"name":"MustMintAtLeastOneToken","type":"error"},{"inputs":[],"name":"NeedExactPayment","type":"error"},{"inputs":[],"name":"NoMoreRemainingKeyMints","type":"error"},{"inputs":[],"name":"NotEnoughAvailableTokens","type":"error"},{"inputs":[],"name":"NotOwnerNorApproved","type":"error"},{"inputs":[],"name":"NothingToWithdraw","type":"error"},{"inputs":[],"name":"TokenAlreadyExists","type":"error"},{"inputs":[],"name":"TokenDoesNotExist","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"inputs":[],"name":"WrongKeyAmount","type":"error"},{"inputs":[],"name":"WrongKeyContract","type":"error"},{"inputs":[],"name":"WrongKeyItem","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"isApproved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"Transfer","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[{"internalType":"address","name":"toAddress","type":"address"},{"internalType":"uint256","name":"numTokens","type":"uint256"}],"name":"airdrop","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"string","name":"input","type":"string"}],"name":"assetNameToAssetId","outputs":[{"internalType":"uint8","name":"assetId","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"babylonBook","outputs":[{"internalType":"contract BabylonBook","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"babylonGame","outputs":[{"internalType":"contract IERC1155","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"babylonKeyTokenId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"extendedPunkDataContract","outputs":[{"internalType":"contract EPD","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"flipMintState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"result","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getConfig","outputs":[{"components":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"nameSingular","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"string","name":"externalLink","type":"string"},{"internalType":"string","name":"tokenDescription","type":"string"},{"internalType":"uint256","name":"costPerToken","type":"uint256"},{"internalType":"uint16","name":"maxSupply","type":"uint16"},{"internalType":"uint16","name":"remainingSupply","type":"uint16"},{"internalType":"uint8","name":"remainingKeyMints","type":"uint8"},{"internalType":"bool","name":"operatorFilteringEnabled","type":"bool"},{"internalType":"bool","name":"isMintActive","type":"bool"},{"internalType":"bool","name":"contractSealed","type":"bool"}],"internalType":"struct Drunks.ContractConfig","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"result","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"numTokens","type":"uint256"}],"name":"mintPublic","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155BatchReceived","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"result","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"punkId","type":"uint16"}],"name":"punkAttributesAsJSON","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"punkDataContract","outputs":[{"internalType":"contract PunkDataInterface","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"remainingKeyMints","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"remainingSupply","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"sealContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"nameSingular","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"string","name":"externalLink","type":"string"},{"internalType":"string","name":"tokenDescription","type":"string"},{"internalType":"uint256","name":"costPerToken","type":"uint256"},{"internalType":"uint16","name":"maxSupply","type":"uint16"},{"internalType":"uint16","name":"remainingSupply","type":"uint16"},{"internalType":"uint8","name":"remainingKeyMints","type":"uint8"},{"internalType":"bool","name":"operatorFilteringEnabled","type":"bool"},{"internalType":"bool","name":"isMintActive","type":"bool"},{"internalType":"bool","name":"contractSealed","type":"bool"}],"internalType":"struct Drunks.ContractConfig","name":"_config","type":"tuple"}],"name":"setContractConfig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint96","name":"feeNumerator","type":"uint96"}],"name":"setDefaultRoyalty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"value","type":"bool"}],"name":"setOperatorFilteringEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_tokenDescription","type":"string"}],"name":"setTokenDescription","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"enum EPD.PunkAttributeValue[]","name":"femaleValues","type":"uint8[]"},{"internalType":"int8[2][]","name":"femaleTranslations","type":"int8[2][]"},{"internalType":"enum EPD.PunkAttributeValue[]","name":"nonFemaleValues","type":"uint8[]"},{"internalType":"int8[2][]","name":"nonFemaleTranslations","type":"int8[2][]"}],"name":"setTranslations","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"tokenId","type":"uint16"}],"name":"tokenImage","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"numTokens","type":"uint256"}],"name":"totalMintCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000001c00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000024000000000000000000000000000000000000000000000000000000000000002a0000000000000000000000000000000000000000000000000008e1bc9bf04000000000000000000000000000000000000000000000000000000000000000002720000000000000000000000000000000000000000000000000000000000000272000000000000000000000000000000000000000000000000000000000000001900000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000064472756e6b73000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000054472756e6b00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000054452554e4b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002868747470733a2f2f63617073756c6532312e636f6d2f636f6c6c656374696f6e732f6472756e6b73000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002b4f6e65206f662036323620746f6b656e7320696e20746865204472756e6b7320636f6c6c656374696f6e2e000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _config (tuple): System.Collections.Generic.List`1[Nethereum.ABI.FunctionEncoding.ParameterOutput]

-----Encoded View---------------
25 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000020
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000180
Arg [2] : 00000000000000000000000000000000000000000000000000000000000001c0
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000200
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000240
Arg [5] : 00000000000000000000000000000000000000000000000000000000000002a0
Arg [6] : 000000000000000000000000000000000000000000000000008e1bc9bf040000
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000272
Arg [8] : 0000000000000000000000000000000000000000000000000000000000000272
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000019
Arg [10] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [11] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [12] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [13] : 0000000000000000000000000000000000000000000000000000000000000006
Arg [14] : 4472756e6b730000000000000000000000000000000000000000000000000000
Arg [15] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [16] : 4472756e6b000000000000000000000000000000000000000000000000000000
Arg [17] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [18] : 4452554e4b000000000000000000000000000000000000000000000000000000
Arg [19] : 0000000000000000000000000000000000000000000000000000000000000028
Arg [20] : 68747470733a2f2f63617073756c6532312e636f6d2f636f6c6c656374696f6e
Arg [21] : 732f6472756e6b73000000000000000000000000000000000000000000000000
Arg [22] : 000000000000000000000000000000000000000000000000000000000000002b
Arg [23] : 4f6e65206f662036323620746f6b656e7320696e20746865204472756e6b7320
Arg [24] : 636f6c6c656374696f6e2e000000000000000000000000000000000000000000