Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

pragma solidity >=0.8.7 <0.9.0;

import {ERC721} from "./ERC721.sol";
import {ERC721Enumerable} from "./ERC721Enumerable.sol";
import {ERC1155} from "./ERC1155.sol";
import {Ownable} from "./Ownable.sol";

contract ERC721Factory {
    function deployERC721(
        address originalAddress,
        string memory name,
        string memory symbol,
        string memory baseURI,
        string memory extension,
        address royaltyRecipient,
        uint256 royaltyBps
    ) public returns (address) {
        ERC721 newCollection =
            new ERC721(originalAddress, name, symbol, baseURI, extension, royaltyRecipient, royaltyBps);
        Ownable(newCollection).transferOwnership(msg.sender);
        return address(newCollection);
    }

    function deployERC721Enumerable(
        address originalAddress,
        string memory name,
        string memory symbol,
        string memory baseURI,
        string memory extension,
        address royaltyRecipient,
        uint256 royaltyBps
    ) public returns (address) {
        ERC721 newCollection =
            new ERC721Enumerable(originalAddress, name, symbol, baseURI, extension, royaltyRecipient, royaltyBps);
        Ownable(newCollection).transferOwnership(msg.sender);
        return address(newCollection);
    }
}

contract ERC1155Factory {
    function deployERC1155(address originalAddress, address royaltyRecipient, uint256 royaltyBps)
        public
        returns (address)
    {
        ERC1155 newCollection = new ERC1155(originalAddress, royaltyRecipient, royaltyBps);
        Ownable(newCollection).transferOwnership(msg.sender);
        return address(newCollection);
    }
}

contract NFTFactory {
    ERC721Factory public immutable erc721Factory;
    ERC1155Factory public immutable erc1155Factory;

    constructor(address _erc721Factory, address _erc1155Factory) {
        erc721Factory = ERC721Factory(_erc721Factory);
        erc1155Factory = ERC1155Factory(_erc1155Factory);
    }

    function deployERC721(
        address originalAddress,
        string memory name,
        string memory symbol,
        string memory baseURI,
        string memory extension,
        address royaltyRecipient,
        uint256 royaltyBps
    ) public returns (address newContract) {
        newContract =
            erc721Factory.deployERC721(originalAddress, name, symbol, baseURI, extension, royaltyRecipient, royaltyBps);
        Ownable(newContract).transferOwnership(msg.sender);
        return newContract;
    }

    function deployERC721Enumerable(
        address originalAddress,
        string memory name,
        string memory symbol,
        string memory baseURI,
        string memory extension,
        address royaltyRecipient,
        uint256 royaltyBps
    ) public returns (address newContract) {
        newContract = erc721Factory.deployERC721Enumerable(
            originalAddress, name, symbol, baseURI, extension, royaltyRecipient, royaltyBps
        );
        Ownable(newContract).transferOwnership(msg.sender);
        return newContract;
    }

    function deployERC1155(address originalAddress, address royaltyRecipient, uint256 royaltyBps, string memory name)
        public
        returns (address newContract)
    {
        newContract = erc1155Factory.deployERC1155(originalAddress, royaltyRecipient, royaltyBps);
        ERC1155(newContract).setName(name);
        Ownable(newContract).transferOwnership(msg.sender);
        return newContract;
    }
}

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

import {ERC721Base} from "./ERC721Base.sol";
import {LibString} from "./utils/LibString.sol";
import {ERC2981} from "./ERC2981.sol";
import {PermissionedMintingNFT} from "./PermissionedMintingNFT.sol";
import {BridgedNFT} from "./BridgedNFT.sol";

contract ERC721 is ERC721Base, ERC2981, PermissionedMintingNFT, BridgedNFT {
    // NFT Metadata
    string private _name;
    string private _symbol;
    string private _baseURI;
    string private _extension;
    uint256 private _totalSupply;
    mapping(uint256 => string) private _tokenURIs;

    // Custom errors
    error TokenExists();
    error MismatchedLengths();

    constructor(
        address originalAddress,
        string memory name,
        string memory symbol,
        string memory baseURI,
        string memory hasExtension,
        address royaltyRecipient,
        uint256 royaltyBps
    ) ERC2981(royaltyRecipient, royaltyBps) PermissionedMintingNFT() BridgedNFT(originalAddress) {
        _name = name;
        _symbol = symbol;
        _baseURI = baseURI;
        _extension = hasExtension;
    }

    function name() public view override returns (string memory) {
        return _name;
    }

    function symbol() public view override returns (string memory) {
        return _symbol;
    }

    function totalSupply() public virtual view returns (uint256) {
        return _totalSupply;
    }

    function tokenURI(uint256 tokenId) public view override returns (string memory) {
        if (!_exists(tokenId)) revert TokenDoesNotExist();
        if (bytes(_tokenURIs[tokenId]).length != 0) {
            return _tokenURIs[tokenId];
        }
        return string(abi.encodePacked(_baseURI, LibString.toString(tokenId), _extension));
    }

    function setBaseURI(string memory baseURI) external onlyOwner {
        _baseURI = baseURI;
    }

    function batchSetTokenURIs(uint256 startId, string[] calldata uris) public onlyOwner {
        for (uint256 i = 0; i < uris.length; ++i) {
            _tokenURIs[startId + i] = uris[i];
        }
    }

    struct AirdropUnit {
        address to;
        uint256[] ids;
    }

    function bulkAirdrop(AirdropUnit[] calldata airdropUnits) public mintIsOpen onlyMinter {
        for (uint256 i = 0; i < airdropUnits.length; ++i) {
            for (uint256 j = 0; j < airdropUnits[i].ids.length; j++) {
                uint256 id = airdropUnits[i].ids[j];
                if (_exists(id)) {
                    _burn(id);
                }
                _totalSupply += 1;
                _mint(airdropUnits[i].to, id);
            }
        }
    }

    function burn(uint256 tokenId) public mintIsOpen onlyMinter {
        _totalSupply -= 1;
        _burn(tokenId);
    }

    function setRoyalties(address recipient, uint256 bps) external onlyOwner {
        _setRoyalties(recipient, bps);
    }

    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            let s := shr(224, interfaceId)
            // ERC165: 0x01ffc9a7, ERC2981: 0x2a55205a
            result := or(eq(s, 0x01ffc9a7), eq(s, 0x2a55205a))
            // ERC721Metadata: 0x5b5e139f
            result := or(result, eq(s, 0x5b5e139f))
            // ERC721: 0x80ac58cd
            result := or(result, eq(s, 0x80ac58cd))
        }
    }
}

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

import {ERC721} from "./ERC721.sol";

contract ERC721Enumerable is ERC721 {
    // array with all token IDs, used for enumeration
    uint256[] private _allTokens;
    // Mapping from token ID to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

    // Mapping from owner to list-as-mapping of owned token IDs
    mapping(address owner => mapping(uint256 index => uint256)) private _ownedTokens;
    // Mapping from token ID to index in the ownedTokens mapping
    mapping(uint256 tokenId => uint256) private _ownedTokensIndex;

    function totalSupply() public view override returns (uint256) {
        return _allTokens.length;
    }

    function tokenByIndex(uint256 index) public view returns (uint256) {
        require(index < totalSupply(), "ERC721Enumerable: INVALID_INDEX");
        return _allTokens[index];
    }

    function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
        require(index < balanceOf(owner), "ERC721Enumerable: INVALID_INDEX");
        return _ownedTokens[owner][index];
    }

    constructor(
        address originalAddress,
        string memory name,
        string memory symbol,
        string memory baseURI,
        string memory hasExtension,
        address royaltyRecipient,
        uint256 royaltyBps
    ) ERC721(originalAddress, name, symbol, baseURI, hasExtension, royaltyRecipient, royaltyBps) {}

    function _beforeTokenTransfer(address _from, address _to, uint256 _tokenId) internal override {
        if (_from == address(0)) {
            _addTokenToAllTokensEnumeration(_tokenId);
        } else if (_from != _to) {
            _removeTokenFromOwnerEnumeration(_from, _tokenId);
        }
        if (_to == address(0)) {
            _removeTokenFromAllTokensEnumeration(_tokenId);
            _removeTokenFromOwnerEnumeration(_from, _tokenId);
        } else if (_to != _from) {
            _addTokenToOwnerEnumeration(_to, _tokenId);
        }
    }

    /* From OZ ERC721Enumerable */
    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        // NOTE: Balance has not been incremented yet when this is called.
        // Because of this, we don't subtract 1 from balanceOf(to) to get the index.
        // Not only is this correct, it also prevents underflow on mint.
        // The alternative would be moving this to the _afterTokenTransfer hook,
        // but that would breack CEI (reentrancy)
        uint256 length = balanceOf(to);
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        // this decrement is safe because balanceOf has not been updated yet
        // so if a user is sending their last token, balanceOf(from) will return 1
        // and the value of lastTokenIndex will correctly be 0
        uint256 lastTokenIndex = balanceOf(from) - 1;
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        mapping(uint256 index => uint256) storage _ownedTokensByOwner = _ownedTokens[from];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokensByOwner[lastTokenIndex];

            _ownedTokensByOwner[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokensByOwner[lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }

    /* ERC165 */

    function supportsInterface(bytes4 interfaceId) public pure override returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            let s := shr(224, interfaceId)
            // ERC165: 0x01ffc9a7
            // ERC2981: 0x2a55205a
            result := or(eq(s, 0x01ffc9a7), eq(s, 0x2a55205a))
            // ERC721Metadata: 0x5b5e139f
            result := or(result, eq(s, 0x5b5e139f))
            // ERC721: 0x80ac58cd
            result := or(result, eq(s, 0x80ac58cd))
            // ERC721Enumerable: 0x780e9d63
            result := or(result, eq(s, 0x780e9d63))
        }
    }
}

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

import {ERC1155Base} from "./ERC1155Base.sol";
import {ERC2981} from "./ERC2981.sol";
import {LibString} from "./utils/LibString.sol";
import {PermissionedMintingNFT} from "./PermissionedMintingNFT.sol";
import {BridgedNFT} from "./BridgedNFT.sol";

contract ERC1155 is ERC1155Base, ERC2981, PermissionedMintingNFT, BridgedNFT {
    // NFT Metadata
    string public name;
    // tokenURI overrides everything
    mapping(uint256 => string) private _tokenURIs;
    bool public burningEnabled = true;

    error URINotSet();
    error BurningIsDisabled();

    event BurningDisabled();

    struct AirdropUnit {
        address to;
        uint256[] ids;
        uint256[] amounts;
        bytes data;
    }

    constructor(address originalAddress, address royaltyRecipient, uint256 royaltyBps)
        ERC2981(royaltyRecipient, royaltyBps)
        PermissionedMintingNFT()
        BridgedNFT(originalAddress)
    {}

    function setName(string memory _name) external onlyOwner {
        name = _name;
    }

    function mint(address to, uint256 id, uint256 amount, bytes memory data) public mintIsOpen onlyMinter {
        _mint(to, id, amount, data);
    }

    function burn(address from, uint256 id, uint256 amount) public mintIsOpen onlyMinter {
        if (!burningEnabled) revert BurningIsDisabled();
        _burn(from, id, amount);
    }

    function disableBurning() external onlyOwner {
        burningEnabled = false;
        emit BurningDisabled();
    }

    function bulkAirdrop(AirdropUnit[] calldata airdrops) public mintIsOpen onlyMinter {
        for (uint256 i = 0; i < airdrops.length; ++i) {
            _batchMint(airdrops[i].to, airdrops[i].ids, airdrops[i].amounts, airdrops[i].data);
        }
    }

    function batchSetTokenURIs(uint256 startId, string[] calldata uris) public onlyMinter {
        for (uint256 i = 0; i < uris.length; ++i) {
            _tokenURIs[startId + i] = uris[i];
        }
    }

    function setRoyalties(address recipient, uint256 bps) external onlyOwner {
        _setRoyalties(recipient, bps);
    }

    function uri(uint256 id) public view override returns (string memory) {
        if (bytes(_tokenURIs[id]).length != 0) {
            return _tokenURIs[id];
        } else {
            revert URINotSet();
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;

/**
 * @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.
 *
 * The initial owner is set to the address provided by the deployer. 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 {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @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 {
        if (owner() != msg.sender) {
            revert OwnableUnauthorizedAccount(msg.sender);
        }
    }

    /**
     * @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 {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _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
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)
///
/// @dev Note:
/// - The ERC721 standard allows for self-approvals.
///   For performance, this implementation WILL NOT revert for such actions.
///   Please add any checks with overrides if desired.
/// - For performance, methods are made payable where permitted by the ERC721 standard.
/// - The `safeTransfer` functions use the identity precompile (0x4)
///   to copy memory internally.
///
/// If you are overriding:
/// - NEVER violate the ERC721 invariant:
///   the balance of an owner MUST always be equal to their number of ownership slots.
///   The transfer functions do not have an underflow guard for user token balances.
/// - Make sure all variables written to storage are properly cleaned
//    (e.g. the bool value for `isApprovedForAll` MUST be either 1 or 0 under the hood).
/// - Check that the overridden function is actually used in the function you want to
///   change the behavior of. Much of the code has been manually inlined for performance.
abstract contract ERC721Base {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         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..255] `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..255] `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 manage 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(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 an {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 an {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)
            // forgefmt: disable-next-item
            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 the token does not exist, or if `from` is not the owner.
            if iszero(mul(owner, eq(owner, from))) {
                // `TokenDoesNotExist()`, `TransferFromIncorrectOwner()`.
                mstore(shl(2, iszero(owner)), 0xceea21b6a1148100)
                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)
                // Revert if `to` is the zero address, or if the account balance overflows.
                if iszero(mul(to, and(toBalanceSlotPacked, _MAX_ACCOUNT_BALANCE))) {
                    // `TransferToZeroAddress()`, `AccountBalanceOverflow()`.
                    mstore(shl(2, iszero(to)), 0xea553b3401336cea)
                    revert(0x1c, 0x04)
                }
                sstore(toBalanceSlot, toBalanceSlotPacked)
            }
            // Emit the {Transfer} event.
            log4(codesize(), 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 := iszero(iszero(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             */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    // For performance, no events are emitted for the hitchhiking setters.
    // Please emit your own events if required.

    /// @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))
            // 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)
                // Revert if `to` is the zero address, or if the account balance overflows.
                if iszero(mul(to, and(balanceSlotPacked, _MAX_ACCOUNT_BALANCE))) {
                    // `TransferToZeroAddress()`, `AccountBalanceOverflow()`.
                    mstore(shl(2, iszero(to)), 0xea553b3401336cea)
                    revert(0x1c, 0x04)
                }
                sstore(balanceSlot, balanceSlotPacked)
            }
            // Emit the {Transfer} event.
            log4(codesize(), 0x00, _TRANSFER_EVENT_SIGNATURE, 0, to, id)
        }
        _afterTokenTransfer(address(0), to, id);
    }

    /// @dev Mints token `id` to `to`, and updates the extra data for token `id` to `value`.
    /// Does NOT check if token `id` already exists (assumes `id` is auto-incrementing).
    ///
    /// Requirements:
    ///
    /// - `to` cannot be the zero address.
    ///
    /// Emits a {Transfer} event.
    function _mintAndSetExtraDataUnchecked(address to, uint256 id, uint96 value) internal virtual {
        _beforeTokenTransfer(address(0), to, id);
        /// @solidity memory-safe-assembly
        assembly {
            // Clear the upper 96 bits.
            to := shr(96, shl(96, to))
            // Update with the owner and extra data.
            mstore(0x00, id)
            mstore(0x1c, _ERC721_MASTER_SLOT_SEED)
            sstore(add(id, add(id, keccak256(0x00, 0x20))), or(shl(160, value), to))
            // Increment the balance of the owner.
            {
                mstore(0x00, to)
                let balanceSlot := keccak256(0x0c, 0x1c)
                let balanceSlotPacked := add(sload(balanceSlot), 1)
                // Revert if `to` is the zero address, or if the account balance overflows.
                if iszero(mul(to, and(balanceSlotPacked, _MAX_ACCOUNT_BALANCE))) {
                    // `TransferToZeroAddress()`, `AccountBalanceOverflow()`.
                    mstore(shl(2, iszero(to)), 0xea553b3401336cea)
                    revert(0x1c, 0x04)
                }
                sstore(balanceSlot, balanceSlotPacked)
            }
            // Emit the {Transfer} event.
            log4(codesize(), 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(codesize(), 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 manage 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 manage the token.
                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 {Approval} 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(codesize(), 0x00, _APPROVAL_EVENT_SIGNATURE, owner, account, id)
        }
    }

    /// @dev Approve or remove the `operator` as an operator for `by`,
    /// without authorization checks.
    ///
    /// Emits an {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 the token does not exist, or if `from` is not the owner.
            if iszero(mul(owner, eq(owner, from))) {
                // `TokenDoesNotExist()`, `TransferFromIncorrectOwner()`.
                mstore(shl(2, iszero(owner)), 0xceea21b6a1148100)
                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)
                // Revert if `to` is the zero address, or if the account balance overflows.
                if iszero(mul(to, and(toBalanceSlotPacked, _MAX_ACCOUNT_BALANCE))) {
                    // `TransferToZeroAddress()`, `AccountBalanceOverflow()`.
                    mstore(shl(2, iszero(to)), 0xea553b3401336cea)
                    revert(0x1c, 0x04)
                }
                sstore(toBalanceSlot, toBalanceSlotPacked)
            }
            // Emit the {Transfer} event.
            log4(codesize(), 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 call reverts.
                    returndatacopy(m, 0x00, returndatasize())
                    revert(m, returndatasize())
                }
            }
            // 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 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)
///
/// @dev Note:
/// For performance and bytecode compactness, most of the string operations are restricted to
/// byte strings (7-bit ASCII), except where otherwise specified.
/// Usage of byte string operations on charsets with runes spanning two or more bytes
/// can lead to undefined behavior.
library LibString {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                        CUSTOM ERRORS                       */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

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

    /// @dev The length of the string is more than 32 bytes.
    error TooBigForSmallString();

    /// @dev The input string must be a 7-bit ASCII.
    error StringNot7BitASCII();

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

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

    /// @dev Lookup for '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.
    uint128 internal constant ALPHANUMERIC_7_BIT_ASCII = 0x7fffffe07fffffe03ff000000000000;

    /// @dev Lookup for 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.
    uint128 internal constant LETTERS_7_BIT_ASCII = 0x7fffffe07fffffe0000000000000000;

    /// @dev Lookup for 'abcdefghijklmnopqrstuvwxyz'.
    uint128 internal constant LOWERCASE_7_BIT_ASCII = 0x7fffffe000000000000000000000000;

    /// @dev Lookup for 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.
    uint128 internal constant UPPERCASE_7_BIT_ASCII = 0x7fffffe0000000000000000;

    /// @dev Lookup for '0123456789'.
    uint128 internal constant DIGITS_7_BIT_ASCII = 0x3ff000000000000;

    /// @dev Lookup for '0123456789abcdefABCDEF'.
    uint128 internal constant HEXDIGITS_7_BIT_ASCII = 0x7e0000007e03ff000000000000;

    /// @dev Lookup for '01234567'.
    uint128 internal constant OCTDIGITS_7_BIT_ASCII = 0xff000000000000;

    /// @dev Lookup for '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c'.
    uint128 internal constant PRINTABLE_7_BIT_ASCII = 0x7fffffffffffffffffffffff00003e00;

    /// @dev Lookup for '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'.
    uint128 internal constant PUNCTUATION_7_BIT_ASCII = 0x78000001f8000001fc00fffe00000000;

    /// @dev Lookup for ' \t\n\r\x0b\x0c'.
    uint128 internal constant WHITESPACE_7_BIT_ASCII = 0x100003e00;

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

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

            let end := result // Cache the end of the memory to calculate the length later.
            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 {} {
                result := add(result, w) // `sub(result, 1)`.
                // Store the character to the pointer.
                // The ASCII index of the '0' character is 48.
                mstore8(result, add(48, mod(temp, 10)))
                temp := div(temp, 10) // Keep dividing `temp` until zero.
                if iszero(temp) { break }
            }
            let n := sub(end, result)
            result := sub(result, 0x20) // Move the pointer 32 bytes back to make room for the length.
            mstore(result, n) // Store the length.
        }
    }

    /// @dev Returns the base 10 decimal representation of `value`.
    function toString(int256 value) internal pure returns (string memory result) {
        if (value >= 0) return toString(uint256(value));
        unchecked {
            result = toString(~uint256(value) + 1);
        }
        /// @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 n := mload(result) // Load the string length.
            mstore(result, 0x2d) // Store the '-' character.
            result := sub(result, 1) // Move back the string pointer by a byte.
            mstore(result, add(n, 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 result) {
        result = toHexStringNoPrefix(value, length);
        /// @solidity memory-safe-assembly
        assembly {
            let n := add(mload(result), 2) // Compute the length.
            mstore(result, 0x3078) // Store the "0x" prefix.
            result := sub(result, 2) // Move the pointer.
            mstore(result, n) // Store the length.
        }
    }

    /// @dev Returns the hexadecimal representation of `value`,
    /// left-padded to an input length of `length` bytes.
    /// The output is not prefixed with "0x" and is 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 result) {
        /// @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.
            result := add(mload(0x40), and(add(shl(1, length), 0x42), not(0x1f)))
            mstore(0x40, add(result, 0x20)) // Allocate memory.
            mstore(result, 0) // Zeroize the slot after the string.

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

            let start := sub(result, 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 {} {
                result := add(result, w) // `sub(result, 2)`.
                mstore8(add(result, 1), mload(and(temp, 15)))
                mstore8(result, mload(and(shr(4, temp), 15)))
                temp := shr(8, temp)
                if iszero(xor(result, start)) { break }
            }
            if temp {
                mstore(0x00, 0x2194895a) // `HexLengthInsufficient()`.
                revert(0x1c, 0x04)
            }
            let n := sub(end, result)
            result := sub(result, 0x20)
            mstore(result, n) // Store the length.
        }
    }

    /// @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 result) {
        result = toHexStringNoPrefix(value);
        /// @solidity memory-safe-assembly
        assembly {
            let n := add(mload(result), 2) // Compute the length.
            mstore(result, 0x3078) // Store the "0x" prefix.
            result := sub(result, 2) // Move the pointer.
            mstore(result, n) // Store the length.
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output is prefixed with "0x".
    /// The output excludes leading "0" from the `toHexString` output.
    /// `0x00: "0x0", 0x01: "0x1", 0x12: "0x12", 0x123: "0x123"`.
    function toMinimalHexString(uint256 value) internal pure returns (string memory result) {
        result = toHexStringNoPrefix(value);
        /// @solidity memory-safe-assembly
        assembly {
            let o := eq(byte(0, mload(add(result, 0x20))), 0x30) // Whether leading zero is present.
            let n := add(mload(result), 2) // Compute the length.
            mstore(add(result, o), 0x3078) // Store the "0x" prefix, accounting for leading zero.
            result := sub(add(result, o), 2) // Move the pointer, accounting for leading zero.
            mstore(result, sub(n, o)) // Store the length, accounting for leading zero.
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output excludes leading "0" from the `toHexStringNoPrefix` output.
    /// `0x00: "0", 0x01: "1", 0x12: "12", 0x123: "123"`.
    function toMinimalHexStringNoPrefix(uint256 value) internal pure returns (string memory result) {
        result = toHexStringNoPrefix(value);
        /// @solidity memory-safe-assembly
        assembly {
            let o := eq(byte(0, mload(add(result, 0x20))), 0x30) // Whether leading zero is present.
            let n := mload(result) // Get the length.
            result := add(result, o) // Move the pointer, accounting for leading zero.
            mstore(result, sub(n, o)) // Store the length, accounting for leading zero.
        }
    }

    /// @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 result) {
        /// @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.
            result := add(mload(0x40), 0x80)
            mstore(0x40, add(result, 0x20)) // Allocate memory.
            mstore(result, 0) // Zeroize the slot after the string.

            let end := result // Cache the end to calculate the length later.
            mstore(0x0f, 0x30313233343536373839616263646566) // Store the "0123456789abcdef" lookup.

            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 {} {
                result := add(result, w) // `sub(result, 2)`.
                mstore8(add(result, 1), mload(and(temp, 15)))
                mstore8(result, mload(and(shr(4, temp), 15)))
                temp := shr(8, temp)
                if iszero(temp) { break }
            }
            let n := sub(end, result)
            result := sub(result, 0x20)
            mstore(result, n) // Store the length.
        }
    }

    /// @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 toHexStringChecksummed(address value) internal pure returns (string memory result) {
        result = toHexString(value);
        /// @solidity memory-safe-assembly
        assembly {
            let mask := shl(6, div(not(0), 255)) // `0b010000000100000000 ...`
            let o := add(result, 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 result) {
        result = toHexStringNoPrefix(value);
        /// @solidity memory-safe-assembly
        assembly {
            let n := add(mload(result), 2) // Compute the length.
            mstore(result, 0x3078) // Store the "0x" prefix.
            result := sub(result, 2) // Move the pointer.
            mstore(result, n) // Store 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 result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := mload(0x40)
            // Allocate 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(result, 0x80))
            mstore(0x0f, 0x30313233343536373839616263646566) // Store the "0123456789abcdef" lookup.

            result := add(result, 2)
            mstore(result, 40) // Store the length.
            let o := add(result, 0x20)
            mstore(add(o, 40), 0) // Zeroize the slot after the string.
            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 result) {
        result = toHexStringNoPrefix(raw);
        /// @solidity memory-safe-assembly
        assembly {
            let n := add(mload(result), 2) // Compute the length.
            mstore(result, 0x3078) // Store the "0x" prefix.
            result := sub(result, 2) // Move the pointer.
            mstore(result, n) // Store 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 result) {
        /// @solidity memory-safe-assembly
        assembly {
            let n := mload(raw)
            result := add(mload(0x40), 2) // Skip 2 bytes for the optional prefix.
            mstore(result, add(n, n)) // Store the length of the output.

            mstore(0x0f, 0x30313233343536373839616263646566) // Store the "0123456789abcdef" lookup.
            let o := add(result, 0x20)
            let end := add(raw, n)
            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 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 {
            result := 1
            let mask := shl(7, div(not(0), 255))
            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)
            }
        }
    }

    /// @dev Returns if this string is a 7-bit ASCII string,
    /// AND all characters are in the `allowed` lookup.
    /// Note: If `s` is empty, returns true regardless of `allowed`.
    function is7BitASCII(string memory s, uint128 allowed) internal pure returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := 1
            if mload(s) {
                let allowed_ := shr(128, shl(128, allowed))
                let o := add(s, 0x20)
                for { let end := add(o, mload(s)) } 1 {} {
                    result := and(result, shr(byte(0, mload(o)), allowed_))
                    o := add(o, 1)
                    if iszero(and(result, lt(o, end))) { break }
                }
            }
        }
    }

    /// @dev Converts the bytes in the 7-bit ASCII string `s` to
    /// an allowed lookup for use in `is7BitASCII(s, allowed)`.
    /// To save runtime gas, you can cache the result in an immutable variable.
    function to7BitASCIIAllowedLookup(string memory s) internal pure returns (uint128 result) {
        /// @solidity memory-safe-assembly
        assembly {
            if mload(s) {
                let o := add(s, 0x20)
                for { let end := add(o, mload(s)) } 1 {} {
                    result := or(result, shl(byte(0, mload(o)), 1))
                    o := add(o, 1)
                    if iszero(lt(o, end)) { break }
                }
                if shr(128, result) {
                    mstore(0x00, 0xc9807e0d) // `StringNot7BitASCII()`.
                    revert(0x1c, 0x04)
                }
            }
        }
    }

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

    // For performance and bytecode compactness, byte string operations are restricted
    // to 7-bit ASCII strings. All offsets are byte offsets, not UTF character offsets.
    // Usage of byte string operations on charsets with runes spanning two or more bytes
    // can lead to undefined behavior.

    /// @dev Returns `subject` all occurrences of `needle` replaced with `replacement`.
    function replace(string memory subject, string memory needle, string memory replacement)
        internal
        pure
        returns (string memory result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            result := mload(0x40)
            let needleLen := mload(needle)
            let replacementLen := mload(replacement)
            let d := sub(result, subject) // Memory difference.
            let i := add(subject, 0x20) // Subject bytes pointer.
            let end := add(i, mload(subject))
            if iszero(gt(needleLen, mload(subject))) {
                let subjectSearchEnd := add(sub(end, needleLen), 1)
                let h := 0 // The hash of `needle`.
                if iszero(lt(needleLen, 0x20)) { h := keccak256(add(needle, 0x20), needleLen) }
                let s := mload(add(needle, 0x20))
                for { let m := shl(3, sub(0x20, and(needleLen, 0x1f))) } 1 {} {
                    let t := mload(i)
                    // Whether the first `needleLen % 32` bytes of `subject` and `needle` matches.
                    if iszero(shr(m, xor(t, s))) {
                        if h {
                            if iszero(eq(keccak256(i, needleLen), h)) {
                                mstore(add(i, d), t)
                                i := add(i, 1)
                                if iszero(lt(i, subjectSearchEnd)) { break }
                                continue
                            }
                        }
                        // Copy the `replacement` one word at a time.
                        for { let j := 0 } 1 {} {
                            mstore(add(add(i, d), j), mload(add(add(replacement, 0x20), j)))
                            j := add(j, 0x20)
                            if iszero(lt(j, replacementLen)) { break }
                        }
                        d := sub(add(d, replacementLen), needleLen)
                        if needleLen {
                            i := add(i, needleLen)
                            if iszero(lt(i, subjectSearchEnd)) { break }
                            continue
                        }
                    }
                    mstore(add(i, d), t)
                    i := add(i, 1)
                    if iszero(lt(i, subjectSearchEnd)) { break }
                }
            }
            let n := add(sub(d, add(result, 0x20)), end)
            // Copy the rest of the string one word at a time.
            for {} lt(i, end) { i := add(i, 0x20) } { mstore(add(i, d), mload(i)) }
            let o := add(i, d)
            mstore(o, 0) // Zeroize the slot after the string.
            mstore(0x40, add(o, 0x20)) // Allocate memory.
            mstore(result, n) // Store the length.
        }
    }

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

                subject := add(subjectStart, from)
                let end := add(sub(add(subjectStart, subjectLen), needleLen), 1)
                let m := shl(3, sub(0x20, and(needleLen, 0x1f)))
                let s := mload(add(needle, 0x20))

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

                if iszero(lt(needleLen, 0x20)) {
                    for { let h := keccak256(add(needle, 0x20), needleLen) } 1 {} {
                        if iszero(shr(m, xor(mload(subject), s))) {
                            if eq(keccak256(subject, needleLen), 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 `needle` in `subject`,
    /// needleing from left to right.
    /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `needle` is not found.
    function indexOf(string memory subject, string memory needle) internal pure returns (uint256 result) {
        result = indexOf(subject, needle, 0);
    }

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

                let fromMax := sub(mload(subject), needleLen)
                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(needle, 0x20), needleLen) } 1 {} {
                    if eq(keccak256(subject, needleLen), 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 `needle` in `subject`,
    /// needleing from right to left.
    /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `needle` is not found.
    function lastIndexOf(string memory subject, string memory needle) internal pure returns (uint256 result) {
        result = lastIndexOf(subject, needle, type(uint256).max);
    }

    /// @dev Returns true if `needle` is found in `subject`, false otherwise.
    function contains(string memory subject, string memory needle) internal pure returns (bool) {
        return indexOf(subject, needle) != NOT_FOUND;
    }

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

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

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

    /// @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 subjectLen := mload(subject)
            if iszero(gt(subjectLen, end)) { end := subjectLen }
            if iszero(gt(subjectLen, start)) { start := subjectLen }
            if lt(start, end) {
                result := mload(0x40)
                let n := sub(end, start)
                let i := add(subject, start)
                let w := not(0x1f)
                // Copy the `subject` one word at a time, backwards.
                for { let j := and(add(n, 0x1f), w) } 1 {} {
                    mstore(add(result, j), mload(add(i, j)))
                    j := add(j, w) // `sub(j, 0x20)`.
                    if iszero(j) { break }
                }
                let o := add(add(result, 0x20), n)
                mstore(o, 0) // Zeroize the slot after the string.
                mstore(0x40, add(o, 0x20)) // Allocate memory.
                mstore(result, n) // Store the length.
            }
        }
    }

    /// @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, type(uint256).max);
    }

    /// @dev Returns all the indices of `needle` in `subject`.
    /// The indices are byte offsets.
    function indicesOf(string memory subject, string memory needle) internal pure returns (uint256[] memory result) {
        /// @solidity memory-safe-assembly
        assembly {
            let searchLen := mload(needle)
            if iszero(gt(searchLen, mload(subject))) {
                result := mload(0x40)
                let i := add(subject, 0x20)
                let o := add(result, 0x20)
                let subjectSearchEnd := add(sub(add(i, mload(subject)), searchLen), 1)
                let h := 0 // The hash of `needle`.
                if iszero(lt(searchLen, 0x20)) { h := keccak256(add(needle, 0x20), searchLen) }
                let s := mload(add(needle, 0x20))
                for { let m := shl(3, sub(0x20, and(searchLen, 0x1f))) } 1 {} {
                    let t := mload(i)
                    // Whether the first `searchLen % 32` bytes of `subject` and `needle` matches.
                    if iszero(shr(m, xor(t, s))) {
                        if h {
                            if iszero(eq(keccak256(i, searchLen), h)) {
                                i := add(i, 1)
                                if iszero(lt(i, subjectSearchEnd)) { break }
                                continue
                            }
                        }
                        mstore(o, sub(i, add(subject, 0x20))) // Append to `result`.
                        o := add(o, 0x20)
                        i := add(i, searchLen) // Advance `i` by `searchLen`.
                        if searchLen {
                            if iszero(lt(i, subjectSearchEnd)) { break }
                            continue
                        }
                    }
                    i := add(i, 1)
                    if iszero(lt(i, subjectSearchEnd)) { break }
                }
                mstore(result, shr(5, sub(o, add(result, 0x20)))) // Store the length of `result`.
                // Allocate memory for result.
                // We allocate one more word, so this array can be recycled for {split}.
                mstore(0x40, add(o, 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))
            for { let prevIndex := 0 } 1 {} {
                let index := mload(indexPtr)
                mstore(indexPtr, 0x60)
                if iszero(eq(index, prevIndex)) {
                    let element := mload(0x40)
                    let l := sub(index, prevIndex)
                    mstore(element, l) // Store the length of the element.
                    // Copy the `subject` one word at a time, backwards.
                    for { let o := and(add(l, 0x1f), w) } 1 {} {
                        mstore(add(element, o), mload(add(add(subject, prevIndex), o)))
                        o := add(o, w) // `sub(o, 0x20)`.
                        if iszero(o) { break }
                    }
                    mstore(add(add(element, 0x20), l), 0) // Zeroize the slot after the string.
                    // Allocate memory for the length and the bytes, rounded up to a multiple of 32.
                    mstore(0x40, add(element, and(add(l, 0x3f), w)))
                    mstore(indexPtr, element) // Store the `element` into the array.
                }
                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 {
            result := mload(0x40)
            let w := not(0x1f)
            let aLen := mload(a)
            // Copy `a` one word at a time, backwards.
            for { let o := and(add(aLen, 0x20), w) } 1 {} {
                mstore(add(result, o), mload(add(a, o)))
                o := add(o, w) // `sub(o, 0x20)`.
                if iszero(o) { break }
            }
            let bLen := mload(b)
            let output := add(result, aLen)
            // Copy `b` one word at a time, backwards.
            for { let o := and(add(bLen, 0x20), w) } 1 {} {
                mstore(add(output, o), mload(add(b, o)))
                o := add(o, w) // `sub(o, 0x20)`.
                if iszero(o) { break }
            }
            let totalLen := add(aLen, bLen)
            let last := add(add(result, 0x20), totalLen)
            mstore(last, 0) // Zeroize the slot after the string.
            mstore(result, totalLen) // Store the length.
            mstore(0x40, add(last, 0x20)) // Allocate memory.
        }
    }

    /// @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 n := mload(subject)
            if n {
                result := mload(0x40)
                let o := add(result, 0x20)
                let d := sub(subject, result)
                let flags := shl(add(70, shl(5, toUpper)), 0x3ffffff)
                for { let end := add(o, n) } 1 {} {
                    let b := byte(0, mload(add(d, o)))
                    mstore8(o, xor(and(shr(b, flags), 0x20), b))
                    o := add(o, 1)
                    if eq(o, end) { break }
                }
                mstore(result, n) // Store the length.
                mstore(o, 0) // Zeroize the slot after the string.
                mstore(0x40, add(o, 0x20)) // Allocate memory.
            }
        }
    }

    /// @dev Returns a string from a small bytes32 string.
    /// `s` must be null-terminated, or behavior will be undefined.
    function fromSmallString(bytes32 s) internal pure returns (string memory result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := mload(0x40)
            let n := 0
            for {} byte(n, s) { n := add(n, 1) } {} // Scan for '\0'.
            mstore(result, n) // Store the length.
            let o := add(result, 0x20)
            mstore(o, s) // Store the bytes of the string.
            mstore(add(o, n), 0) // Zeroize the slot after the string.
            mstore(0x40, add(result, 0x40)) // Allocate memory.
        }
    }

    /// @dev Returns the small string, with all bytes after the first null byte zeroized.
    function normalizeSmallString(bytes32 s) internal pure returns (bytes32 result) {
        /// @solidity memory-safe-assembly
        assembly {
            for {} byte(result, s) { result := add(result, 1) } {} // Scan for '\0'.
            mstore(0x00, s)
            mstore(result, 0x00)
            result := mload(0x00)
        }
    }

    /// @dev Returns the string as a normalized null-terminated small string.
    function toSmallString(string memory s) internal pure returns (bytes32 result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := mload(s)
            if iszero(lt(result, 33)) {
                mstore(0x00, 0xec92f9a3) // `TooBigForSmallString()`.
                revert(0x1c, 0x04)
            }
            result := shl(shl(3, sub(32, result)), mload(add(s, result)))
        }
    }

    /// @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 {
            result := mload(0x40)
            let end := add(s, mload(s))
            let o := add(result, 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))
            for {} iszero(eq(s, end)) {} {
                s := add(s, 1)
                let c := and(mload(s), 0xff)
                // Not in `["\"","'","&","<",">"]`.
                if iszero(and(shl(c, 1), 0x500000c400000000)) {
                    mstore8(o, c)
                    o := add(o, 1)
                    continue
                }
                let t := shr(248, mload(c))
                mstore(o, mload(and(t, 0x1f)))
                o := add(o, shr(5, t))
            }
            mstore(o, 0) // Zeroize the slot after the string.
            mstore(result, sub(o, add(result, 0x20))) // Store the length.
            mstore(0x40, add(o, 0x20)) // Allocate memory.
        }
    }

    /// @dev Escapes the string to be used within double-quotes in a JSON.
    /// If `addDoubleQuotes` is true, the result will be enclosed in double-quotes.
    function escapeJSON(string memory s, bool addDoubleQuotes) internal pure returns (string memory result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := mload(0x40)
            let o := add(result, 0x20)
            if addDoubleQuotes {
                mstore8(o, 34)
                o := add(1, o)
            }
            // 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))
            for { let end := add(s, mload(s)) } 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(o, c)
                        o := add(o, 1)
                        continue
                    }
                    mstore8(o, 0x5c) // "\\".
                    mstore8(add(o, 1), c)
                    o := add(o, 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(o, mload(0x19)) // "\\u00XX".
                    o := add(o, 6)
                    continue
                }
                mstore8(o, 0x5c) // "\\".
                mstore8(add(o, 1), mload(add(c, 8)))
                o := add(o, 2)
            }
            if addDoubleQuotes {
                mstore8(o, 34)
                o := add(1, o)
            }
            mstore(o, 0) // Zeroize the slot after the string.
            mstore(result, sub(o, add(result, 0x20))) // Store the length.
            mstore(0x40, add(o, 0x20)) // Allocate 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) {
        result = escapeJSON(s, false);
    }

    /// @dev Encodes `s` so that it can be safely used in a URI,
    /// just like `encodeURIComponent` in JavaScript.
    /// See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent
    /// See: https://datatracker.ietf.org/doc/html/rfc2396
    /// See: https://datatracker.ietf.org/doc/html/rfc3986
    function encodeURIComponent(string memory s) internal pure returns (string memory result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := mload(0x40)
            // Store "0123456789ABCDEF" in scratch space.
            // Uppercased to be consistent with JavaScript's implementation.
            mstore(0x0f, 0x30313233343536373839414243444546)
            let o := add(result, 0x20)
            for { let end := add(s, mload(s)) } iszero(eq(s, end)) {} {
                s := add(s, 1)
                let c := and(mload(s), 0xff)
                // If not in `[0-9A-Z-a-z-.!~*'()]`.
                if iszero(and(1, shr(c, 0x47fffffe07fffffe03ff678200000000))) {
                    mstore8(o, 0x25) // '%'.
                    mstore8(add(o, 1), mload(and(shr(4, c), 15)))
                    mstore8(add(o, 2), mload(and(c, 15)))
                    o := add(o, 3)
                    continue
                }
                mstore8(o, c)
                o := add(o, 1)
            }
            mstore(result, sub(o, add(result, 0x20))) // Store the length.
            mstore(o, 0) // Zeroize the slot after the string.
            mstore(0x40, add(o, 0x20)) // Allocate memory.
        }
    }

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

    /// @dev Returns whether `a` equals `b`, where `b` is a null-terminated small string.
    function eqs(string memory a, bytes32 b) internal pure returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            // These should be evaluated on compile time, as far as possible.
            let m := not(shl(7, div(not(iszero(b)), 255))) // `0x7f7f ...`.
            let x := not(or(m, or(b, add(m, and(b, m)))))
            let r := shl(7, iszero(iszero(shr(128, x))))
            r := or(r, shl(6, iszero(iszero(shr(64, shr(r, x))))))
            r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
            r := or(r, shl(4, lt(0xffff, shr(r, x))))
            r := or(r, shl(3, lt(0xff, shr(r, x))))
            // forgefmt: disable-next-item
            result := gt(eq(mload(a), add(iszero(x), xor(31, shr(3, r)))),
                xor(shr(add(8, r), b), shr(add(8, r), mload(add(a, 0x20)))))
        }
    }

    /// @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 behavior is undefined.
    function unpackOne(bytes32 packed) internal pure returns (string memory result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := mload(0x40) // Grab the free memory pointer.
            mstore(0x40, add(result, 0x40)) // Allocate 2 words (1 for the length, 1 for the bytes).
            mstore(result, 0) // Zeroize the length slot.
            mstore(add(result, 0x1f), packed) // Store the length and bytes.
            mstore(add(add(result, 0x20), mload(result)), 0) // Right pad with zeroes.
        }
    }

    /// @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 aLen := mload(a)
            // We don't need to zero right pad the strings,
            // since this is our own custom non-standard packing scheme.
            result :=
                mul(
                    or( // Load the length and the bytes of `a` and `b`.
                    shl(shl(3, sub(0x1f, aLen)), mload(add(a, aLen))), mload(sub(add(b, 0x1e), aLen))),
                    // `totalLen != 0 && totalLen < 31`. Abuses underflow.
                    // Assumes that the lengths are valid and within the block gas limit.
                    lt(sub(add(aLen, 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 behavior is undefined.
    function unpackTwo(bytes32 packed) internal pure returns (string memory resultA, string memory resultB) {
        /// @solidity memory-safe-assembly
        assembly {
            resultA := mload(0x40) // Grab the free memory pointer.
            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 retUnpaddedSize := 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, retUnpaddedSize), 0)
            mstore(retStart, 0x20) // Store the return offset.
            // End the transaction, returning the string.
            return(retStart, and(not(0x1f), add(0x1f, retUnpaddedSize)))
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.8.7 <0.9.0;

abstract contract ERC2981 {
    // ERC165 bytes to add to interface array - set in parent contract
    bytes4 private constant _INTERFACE_ID_ERC2981 = 0x2a55205a;

    uint256 internal _royaltyBps;
    address internal _royaltyRecipient;

    error Invalid();

    constructor(address recipient, uint256 royaltyBps) {
        _setRoyalties(recipient, royaltyBps);
    }

    // Called with the sale price to determine how much royalty
    // is owed and to whom.
    function royaltyInfo(uint256, uint256 _salePrice) external view virtual returns (address, uint256) {
        if (_royaltyBps == 0) {
            return (address(0), 0);
        }
        uint256 royaltyAmount = (_salePrice * _royaltyBps) / 10000;
        return (_royaltyRecipient, royaltyAmount);
    }

    function _setRoyalties(address recipient, uint256 bps) internal {
        if (bps > 10000) revert Invalid();
        _royaltyRecipient = recipient;
        _royaltyBps = bps;
        emit RoyaltiesSet(recipient, bps);
    }

    event RoyaltiesSet(address receiver, uint256 bps);
}

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

import {Ownable} from "./Ownable.sol";

/**
 * @title PermissionedMintingNFT
 * @dev Base contract for NFT collections with permissioned minting functionality
 */
abstract contract PermissionedMintingNFT is Ownable {
    // Mapping of addresses allowed to mint
    mapping(address => bool) private _minters;

    // Global minting enabled flag
    bool public mintingEnabled = true;

    // Events
    event MintRightsGranted(address indexed minter);
    event MintRightsRevoked(address indexed minter);

    // Custom errors
    error NotMinter();
    error MintClosed();

    constructor() Ownable(msg.sender) {}

    // Modifiers
    modifier mintIsOpen() {
        if (!mintingEnabled) {
            revert MintClosed();
        }
        _;
    }

    modifier onlyMinter() {
        if (!_minters[msg.sender] && owner() != msg.sender) {
            revert NotMinter();
        }
        _;
    }

    // Minter management functions
    function setCanMint(address newMinter, bool canMint) external onlyOwner {
        _minters[newMinter] = canMint;
        emit MintRightsGranted(newMinter);
    }

    function renounceMintingRights() external {
        if (!_minters[msg.sender]) {
            revert NotMinter();
        }
        _minters[msg.sender] = false;
        emit MintRightsRevoked(msg.sender);
    }

    function closeMinting() external onlyOwner {
        mintingEnabled = false;
    }

    // Internal helper
    function _isMinter(address account) internal view returns (bool) {
        return _minters[account] || account == owner();
    }
}

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

/**
 * @title BridgedNFT
 * @dev Base contract for NFTs that are bridged from another chain
 */
abstract contract BridgedNFT {
    // The address of the original collection on the source chain
    address public immutable originalCollectionAddress;

    constructor(address originalAddress) {
        originalCollectionAddress = originalAddress;
    }
}

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

/// @notice Simple ERC1155 implementation.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/tokens/ERC1155.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC1155.sol)
/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC1155/ERC1155.sol)
///
/// @dev Note:
/// - The ERC1155 standard allows for self-approvals.
///   For performance, this implementation WILL NOT revert for such actions.
///   Please add any checks with overrides if desired.
/// - The transfer functions use the identity precompile (0x4)
///   to copy memory internally.
///
/// If you are overriding:
/// - Make sure all variables written to storage are properly cleaned
//    (e.g. the bool value for `isApprovedForAll` MUST be either 1 or 0 under the hood).
/// - Check that the overridden function is actually used in the function you want to
///   change the behavior of. Much of the code has been manually inlined for performance.
abstract contract ERC1155Base {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The lengths of the input arrays are not the same.
    error ArrayLengthsMismatch();

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

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

    /// @dev Insufficient balance.
    error InsufficientBalance();

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

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

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

    /// @dev Emitted when `amount` of token `id` is transferred
    /// from `from` to `to` by `operator`.
    event TransferSingle(
        address indexed operator, address indexed from, address indexed to, uint256 id, uint256 amount
    );

    /// @dev Emitted when `amounts` of token `ids` are transferred
    /// from `from` to `to` by `operator`.
    event TransferBatch(
        address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] amounts
    );

    /// @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 Emitted when the Uniform Resource Identifier (URI) for token `id`
    /// is updated to `value`. This event is not used in the base contract.
    /// You may need to emit this event depending on your URI logic.
    ///
    /// See: https://eips.ethereum.org/EIPS/eip-1155#metadata
    event URI(string value, uint256 indexed id);

    /// @dev `keccak256(bytes("TransferSingle(address,address,address,uint256,uint256)"))`.
    uint256 private constant _TRANSFER_SINGLE_EVENT_SIGNATURE =
        0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62;

    /// @dev `keccak256(bytes("TransferBatch(address,address,address,uint256[],uint256[])"))`.
    uint256 private constant _TRANSFER_BATCH_EVENT_SIGNATURE =
        0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb;

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

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

    /// @dev The `ownerSlotSeed` of a given owner is given by.
    /// ```
    ///     let ownerSlotSeed := or(_ERC1155_MASTER_SLOT_SEED, shl(96, owner))
    /// ```
    ///
    /// The balance slot of `owner` is given by.
    /// ```
    ///     mstore(0x20, ownerSlotSeed)
    ///     mstore(0x00, id)
    ///     let balanceSlot := keccak256(0x00, 0x40)
    /// ```
    ///
    /// The operator approval slot of `owner` is given by.
    /// ```
    ///     mstore(0x20, ownerSlotSeed)
    ///     mstore(0x00, operator)
    ///     let operatorApprovalSlot := keccak256(0x0c, 0x34)
    /// ```
    uint256 private constant _ERC1155_MASTER_SLOT_SEED = 0x9a31110384e0b0c9;

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

    /// @dev Returns the URI for token `id`.
    ///
    /// You can either return the same templated URI for all token IDs,
    /// (e.g. "https://example.com/api/{id}.json"),
    /// or return a unique URI for each `id`.
    ///
    /// See: https://eips.ethereum.org/EIPS/eip-1155#metadata
    function uri(uint256 id) public view virtual returns (string memory);

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

    /// @dev Returns the amount of `id` owned by `owner`.
    function balanceOf(address owner, uint256 id) public view virtual returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, _ERC1155_MASTER_SLOT_SEED)
            mstore(0x14, owner)
            mstore(0x00, id)
            result := sload(keccak256(0x00, 0x40))
        }
    }

    /// @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(0x20, _ERC1155_MASTER_SLOT_SEED)
            mstore(0x14, owner)
            mstore(0x00, operator)
            result := sload(keccak256(0x0c, 0x34))
        }
    }

    /// @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(0x20, _ERC1155_MASTER_SLOT_SEED)
            mstore(0x14, caller())
            mstore(0x00, operator)
            sstore(keccak256(0x0c, 0x34), isApproved)
            // Emit the {ApprovalForAll} event.
            mstore(0x00, isApproved)
            // forgefmt: disable-next-line
            log3(0x00, 0x20, _APPROVAL_FOR_ALL_EVENT_SIGNATURE, caller(), shr(96, shl(96, operator)))
        }
    }

    /// @dev Transfers `amount` of `id` from `from` to `to`.
    ///
    /// Requirements:
    /// - `to` cannot be the zero address.
    /// - `from` must have at least `amount` of `id`.
    /// - If the caller is not `from`,
    ///   it must be approved to manage the tokens of `from`.
    /// - If `to` refers to a smart contract, it must implement
    ///   {ERC1155-onERC1155Received}, which is called upon a batch transfer.
    ///
    /// Emits a {TransferSingle} event.
    function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data)
        public
        virtual
    {
        if (_useBeforeTokenTransfer()) {
            _beforeTokenTransfer(from, to, _single(id), _single(amount), data);
        }
        /// @solidity memory-safe-assembly
        assembly {
            let fromSlotSeed := or(_ERC1155_MASTER_SLOT_SEED, shl(96, from))
            let toSlotSeed := or(_ERC1155_MASTER_SLOT_SEED, shl(96, to))
            mstore(0x20, fromSlotSeed)
            // Clear the upper 96 bits.
            from := shr(96, fromSlotSeed)
            to := shr(96, toSlotSeed)
            // Revert if `to` is the zero address.
            if iszero(to) {
                mstore(0x00, 0xea553b34) // `TransferToZeroAddress()`.
                revert(0x1c, 0x04)
            }
            // If the caller is not `from`, do the authorization check.
            if iszero(eq(caller(), from)) {
                mstore(0x00, caller())
                if iszero(sload(keccak256(0x0c, 0x34))) {
                    mstore(0x00, 0x4b6e7f18) // `NotOwnerNorApproved()`.
                    revert(0x1c, 0x04)
                }
            }
            // Subtract and store the updated balance of `from`.
            {
                mstore(0x00, id)
                let fromBalanceSlot := keccak256(0x00, 0x40)
                let fromBalance := sload(fromBalanceSlot)
                if gt(amount, fromBalance) {
                    mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.
                    revert(0x1c, 0x04)
                }
                sstore(fromBalanceSlot, sub(fromBalance, amount))
            }
            // Increase and store the updated balance of `to`.
            {
                mstore(0x20, toSlotSeed)
                let toBalanceSlot := keccak256(0x00, 0x40)
                let toBalanceBefore := sload(toBalanceSlot)
                let toBalanceAfter := add(toBalanceBefore, amount)
                if lt(toBalanceAfter, toBalanceBefore) {
                    mstore(0x00, 0x01336cea) // `AccountBalanceOverflow()`.
                    revert(0x1c, 0x04)
                }
                sstore(toBalanceSlot, toBalanceAfter)
            }
            // Emit a {TransferSingle} event.
            mstore(0x20, amount)
            log4(0x00, 0x40, _TRANSFER_SINGLE_EVENT_SIGNATURE, caller(), from, to)
        }
        if (_useAfterTokenTransfer()) {
            _afterTokenTransfer(from, to, _single(id), _single(amount), data);
        }
        /// @solidity memory-safe-assembly
        assembly {
            // Do the {onERC1155Received} check if `to` is a smart contract.
            if extcodesize(to) {
                // Prepare the calldata.
                let m := mload(0x40)
                // `onERC1155Received(address,address,uint256,uint256,bytes)`.
                mstore(m, 0xf23a6e61)
                mstore(add(m, 0x20), caller())
                mstore(add(m, 0x40), from)
                mstore(add(m, 0x60), id)
                mstore(add(m, 0x80), amount)
                mstore(add(m, 0xa0), 0xa0)
                calldatacopy(add(m, 0xc0), sub(data.offset, 0x20), add(0x20, data.length))
                // Revert if the call reverts.
                if iszero(call(gas(), to, 0, add(m, 0x1c), add(0xc4, data.length), m, 0x20)) {
                    if returndatasize() {
                        // Bubble up the revert if the call reverts.
                        returndatacopy(m, 0x00, returndatasize())
                        revert(m, returndatasize())
                    }
                }
                // Load the returndata and compare it with the function selector.
                if iszero(eq(mload(m), shl(224, 0xf23a6e61))) {
                    mstore(0x00, 0x9c05499b) // `TransferToNonERC1155ReceiverImplementer()`.
                    revert(0x1c, 0x04)
                }
            }
        }
    }

    /// @dev Transfers `amounts` of `ids` from `from` to `to`.
    ///
    /// Requirements:
    /// - `to` cannot be the zero address.
    /// - `from` must have at least `amount` of `id`.
    /// - `ids` and `amounts` must have the same length.
    /// - If the caller is not `from`,
    ///   it must be approved to manage the tokens of `from`.
    /// - If `to` refers to a smart contract, it must implement
    ///   {ERC1155-onERC1155BatchReceived}, which is called upon a batch transfer.
    ///
    /// Emits a {TransferBatch} event.
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) public virtual {
        if (_useBeforeTokenTransfer()) {
            _beforeTokenTransfer(from, to, ids, amounts, data);
        }
        /// @solidity memory-safe-assembly
        assembly {
            if iszero(eq(ids.length, amounts.length)) {
                mstore(0x00, 0x3b800a46) // `ArrayLengthsMismatch()`.
                revert(0x1c, 0x04)
            }
            let fromSlotSeed := or(_ERC1155_MASTER_SLOT_SEED, shl(96, from))
            let toSlotSeed := or(_ERC1155_MASTER_SLOT_SEED, shl(96, to))
            mstore(0x20, fromSlotSeed)
            // Clear the upper 96 bits.
            from := shr(96, fromSlotSeed)
            to := shr(96, toSlotSeed)
            // Revert if `to` is the zero address.
            if iszero(to) {
                mstore(0x00, 0xea553b34) // `TransferToZeroAddress()`.
                revert(0x1c, 0x04)
            }
            // If the caller is not `from`, do the authorization check.
            if iszero(eq(caller(), from)) {
                mstore(0x00, caller())
                if iszero(sload(keccak256(0x0c, 0x34))) {
                    mstore(0x00, 0x4b6e7f18) // `NotOwnerNorApproved()`.
                    revert(0x1c, 0x04)
                }
            }
            // Loop through all the `ids` and update the balances.
            {
                for { let i := shl(5, ids.length) } i {} {
                    i := sub(i, 0x20)
                    let amount := calldataload(add(amounts.offset, i))
                    // Subtract and store the updated balance of `from`.
                    {
                        mstore(0x20, fromSlotSeed)
                        mstore(0x00, calldataload(add(ids.offset, i)))
                        let fromBalanceSlot := keccak256(0x00, 0x40)
                        let fromBalance := sload(fromBalanceSlot)
                        if gt(amount, fromBalance) {
                            mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.
                            revert(0x1c, 0x04)
                        }
                        sstore(fromBalanceSlot, sub(fromBalance, amount))
                    }
                    // Increase and store the updated balance of `to`.
                    {
                        mstore(0x20, toSlotSeed)
                        let toBalanceSlot := keccak256(0x00, 0x40)
                        let toBalanceBefore := sload(toBalanceSlot)
                        let toBalanceAfter := add(toBalanceBefore, amount)
                        if lt(toBalanceAfter, toBalanceBefore) {
                            mstore(0x00, 0x01336cea) // `AccountBalanceOverflow()`.
                            revert(0x1c, 0x04)
                        }
                        sstore(toBalanceSlot, toBalanceAfter)
                    }
                }
            }
            // Emit a {TransferBatch} event.
            {
                let m := mload(0x40)
                // Copy the `ids`.
                mstore(m, 0x40)
                let n := add(0x20, shl(5, ids.length))
                let o := add(m, 0x40)
                calldatacopy(o, sub(ids.offset, 0x20), n)
                // Copy the `amounts`.
                mstore(add(m, 0x20), add(0x40, n))
                calldatacopy(add(o, n), sub(amounts.offset, 0x20), n)
                // Do the emit.
                log4(m, add(add(n, n), 0x40), _TRANSFER_BATCH_EVENT_SIGNATURE, caller(), from, to)
            }
        }
        if (_useAfterTokenTransfer()) {
            _afterTokenTransferCalldata(from, to, ids, amounts, data);
        }
        /// @solidity memory-safe-assembly
        assembly {
            // Do the {onERC1155BatchReceived} check if `to` is a smart contract.
            if extcodesize(to) {
                mstore(0x00, to) // Cache `to` to prevent stack too deep.
                let m := mload(0x40)
                // Prepare the calldata.
                // `onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)`.
                mstore(m, 0xbc197c81)
                mstore(add(m, 0x20), caller())
                mstore(add(m, 0x40), from)
                // Copy the `ids`.
                mstore(add(m, 0x60), 0xa0)
                let n := add(0x20, shl(5, ids.length))
                let o := add(m, 0xc0)
                calldatacopy(o, sub(ids.offset, 0x20), n)
                // Copy the `amounts`.
                let s := add(0xa0, n)
                mstore(add(m, 0x80), s)
                calldatacopy(add(o, n), sub(amounts.offset, 0x20), n)
                // Copy the `data`.
                mstore(add(m, 0xa0), add(s, n))
                calldatacopy(add(o, add(n, n)), sub(data.offset, 0x20), add(0x20, data.length))
                let nAll := add(0xc4, add(data.length, add(n, n)))
                // Revert if the call reverts.
                if iszero(call(gas(), mload(0x00), 0, add(m, 0x1c), nAll, m, 0x20)) {
                    if returndatasize() {
                        // Bubble up the revert if the call reverts.
                        returndatacopy(m, 0x00, returndatasize())
                        revert(m, returndatasize())
                    }
                }
                // Load the returndata and compare it with the function selector.
                if iszero(eq(mload(m), shl(224, 0xbc197c81))) {
                    mstore(0x00, 0x9c05499b) // `TransferToNonERC1155ReceiverImplementer()`.
                    revert(0x1c, 0x04)
                }
            }
        }
    }

    /// @dev Returns the amounts of `ids` for `owners.
    ///
    /// Requirements:
    /// - `owners` and `ids` must have the same length.
    function balanceOfBatch(address[] calldata owners, uint256[] calldata ids)
        public
        view
        virtual
        returns (uint256[] memory balances)
    {
        /// @solidity memory-safe-assembly
        assembly {
            if iszero(eq(ids.length, owners.length)) {
                mstore(0x00, 0x3b800a46) // `ArrayLengthsMismatch()`.
                revert(0x1c, 0x04)
            }
            balances := mload(0x40)
            mstore(balances, ids.length)
            let o := add(balances, 0x20)
            let i := shl(5, ids.length)
            mstore(0x40, add(i, o))
            // Loop through all the `ids` and load the balances.
            for {} i {} {
                i := sub(i, 0x20)
                let owner := calldataload(add(owners.offset, i))
                mstore(0x20, or(_ERC1155_MASTER_SLOT_SEED, shl(96, owner)))
                mstore(0x00, calldataload(add(ids.offset, i)))
                mstore(add(o, i), sload(keccak256(0x00, 0x40)))
            }
        }
    }

    /// @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, ERC1155: 0xd9b67a26, ERC1155MetadataURI: 0x0e89341c.
            result := or(or(eq(s, 0x01ffc9a7), eq(s, 0xd9b67a26)), eq(s, 0x0e89341c))
        }
    }

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

    /// @dev Mints `amount` of `id` to `to`.
    ///
    /// Requirements:
    /// - `to` cannot be the zero address.
    /// - If `to` refers to a smart contract, it must implement
    ///   {ERC1155-onERC1155Received}, which is called upon a batch transfer.
    ///
    /// Emits a {TransferSingle} event.
    function _mint(address to, uint256 id, uint256 amount, bytes memory data) internal virtual {
        if (_useBeforeTokenTransfer()) {
            _beforeTokenTransfer(address(0), to, _single(id), _single(amount), data);
        }
        /// @solidity memory-safe-assembly
        assembly {
            let to_ := shl(96, to)
            // Revert if `to` is the zero address.
            if iszero(to_) {
                mstore(0x00, 0xea553b34) // `TransferToZeroAddress()`.
                revert(0x1c, 0x04)
            }
            // Increase and store the updated balance of `to`.
            {
                mstore(0x20, _ERC1155_MASTER_SLOT_SEED)
                mstore(0x14, to)
                mstore(0x00, id)
                let toBalanceSlot := keccak256(0x00, 0x40)
                let toBalanceBefore := sload(toBalanceSlot)
                let toBalanceAfter := add(toBalanceBefore, amount)
                if lt(toBalanceAfter, toBalanceBefore) {
                    mstore(0x00, 0x01336cea) // `AccountBalanceOverflow()`.
                    revert(0x1c, 0x04)
                }
                sstore(toBalanceSlot, toBalanceAfter)
            }
            // Emit a {TransferSingle} event.
            mstore(0x20, amount)
            log4(0x00, 0x40, _TRANSFER_SINGLE_EVENT_SIGNATURE, caller(), 0, shr(96, to_))
        }
        if (_useAfterTokenTransfer()) {
            _afterTokenTransfer(address(0), to, _single(id), _single(amount), data);
        }
        if (_hasCode(to)) _checkOnERC1155Received(address(0), to, id, amount, data);
    }

    /// @dev Mints `amounts` of `ids` to `to`.
    ///
    /// Requirements:
    /// - `to` cannot be the zero address.
    /// - `ids` and `amounts` must have the same length.
    /// - If `to` refers to a smart contract, it must implement
    ///   {ERC1155-onERC1155BatchReceived}, which is called upon a batch transfer.
    ///
    /// Emits a {TransferBatch} event.
    function _batchMint(address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
        internal
        virtual
    {
        if (_useBeforeTokenTransfer()) {
            _beforeTokenTransfer(address(0), to, ids, amounts, data);
        }
        /// @solidity memory-safe-assembly
        assembly {
            if iszero(eq(mload(ids), mload(amounts))) {
                mstore(0x00, 0x3b800a46) // `ArrayLengthsMismatch()`.
                revert(0x1c, 0x04)
            }
            let to_ := shl(96, to)
            // Revert if `to` is the zero address.
            if iszero(to_) {
                mstore(0x00, 0xea553b34) // `TransferToZeroAddress()`.
                revert(0x1c, 0x04)
            }
            // Loop through all the `ids` and update the balances.
            {
                mstore(0x20, or(_ERC1155_MASTER_SLOT_SEED, to_))
                for { let i := shl(5, mload(ids)) } i { i := sub(i, 0x20) } {
                    let amount := mload(add(amounts, i))
                    // Increase and store the updated balance of `to`.
                    {
                        mstore(0x00, mload(add(ids, i)))
                        let toBalanceSlot := keccak256(0x00, 0x40)
                        let toBalanceBefore := sload(toBalanceSlot)
                        let toBalanceAfter := add(toBalanceBefore, amount)
                        if lt(toBalanceAfter, toBalanceBefore) {
                            mstore(0x00, 0x01336cea) // `AccountBalanceOverflow()`.
                            revert(0x1c, 0x04)
                        }
                        sstore(toBalanceSlot, toBalanceAfter)
                    }
                }
            }
            // Emit a {TransferBatch} event.
            {
                let m := mload(0x40)
                // Copy the `ids`.
                mstore(m, 0x40)
                let n := add(0x20, shl(5, mload(ids)))
                let o := add(m, 0x40)
                pop(staticcall(gas(), 4, ids, n, o, n))
                // Copy the `amounts`.
                mstore(add(m, 0x20), add(0x40, returndatasize()))
                o := add(o, returndatasize())
                n := add(0x20, shl(5, mload(amounts)))
                pop(staticcall(gas(), 4, amounts, n, o, n))
                n := sub(add(o, returndatasize()), m)
                // Do the emit.
                log4(m, n, _TRANSFER_BATCH_EVENT_SIGNATURE, caller(), 0, shr(96, to_))
            }
        }
        if (_useAfterTokenTransfer()) {
            _afterTokenTransfer(address(0), to, ids, amounts, data);
        }
        if (_hasCode(to)) _checkOnERC1155BatchReceived(address(0), to, ids, amounts, data);
    }

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

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

    /// @dev Destroys `amount` of `id` from `from`.
    ///
    /// Requirements:
    /// - `from` must have at least `amount` of `id`.
    /// - If `by` is not the zero address, it must be either `from`,
    ///   or approved to manage the tokens of `from`.
    ///
    /// Emits a {TransferSingle} event.
    function _burn(address by, address from, uint256 id, uint256 amount) internal virtual {
        if (_useBeforeTokenTransfer()) {
            _beforeTokenTransfer(from, address(0), _single(id), _single(amount), "");
        }
        /// @solidity memory-safe-assembly
        assembly {
            let from_ := shl(96, from)
            mstore(0x20, or(_ERC1155_MASTER_SLOT_SEED, from_))
            // If `by` is not the zero address, and not equal to `from`,
            // check if it is approved to manage all the tokens of `from`.
            if iszero(or(iszero(shl(96, by)), eq(shl(96, by), from_))) {
                mstore(0x00, by)
                if iszero(sload(keccak256(0x0c, 0x34))) {
                    mstore(0x00, 0x4b6e7f18) // `NotOwnerNorApproved()`.
                    revert(0x1c, 0x04)
                }
            }
            // Decrease and store the updated balance of `from`.
            {
                mstore(0x00, id)
                let fromBalanceSlot := keccak256(0x00, 0x40)
                let fromBalance := sload(fromBalanceSlot)
                if gt(amount, fromBalance) {
                    mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.
                    revert(0x1c, 0x04)
                }
                sstore(fromBalanceSlot, sub(fromBalance, amount))
            }
            // Emit a {TransferSingle} event.
            mstore(0x20, amount)
            log4(0x00, 0x40, _TRANSFER_SINGLE_EVENT_SIGNATURE, caller(), shr(96, from_), 0)
        }
        if (_useAfterTokenTransfer()) {
            _afterTokenTransfer(from, address(0), _single(id), _single(amount), "");
        }
    }

    /// @dev Equivalent to `_batchBurn(address(0), from, ids, amounts)`.
    function _batchBurn(address from, uint256[] memory ids, uint256[] memory amounts) internal virtual {
        _batchBurn(address(0), from, ids, amounts);
    }

    /// @dev Destroys `amounts` of `ids` from `from`.
    ///
    /// Requirements:
    /// - `ids` and `amounts` must have the same length.
    /// - `from` must have at least `amounts` of `ids`.
    /// - If `by` is not the zero address, it must be either `from`,
    ///   or approved to manage the tokens of `from`.
    ///
    /// Emits a {TransferBatch} event.
    function _batchBurn(address by, address from, uint256[] memory ids, uint256[] memory amounts) internal virtual {
        if (_useBeforeTokenTransfer()) {
            _beforeTokenTransfer(from, address(0), ids, amounts, "");
        }
        /// @solidity memory-safe-assembly
        assembly {
            if iszero(eq(mload(ids), mload(amounts))) {
                mstore(0x00, 0x3b800a46) // `ArrayLengthsMismatch()`.
                revert(0x1c, 0x04)
            }
            let from_ := shl(96, from)
            mstore(0x20, or(_ERC1155_MASTER_SLOT_SEED, from_))
            // If `by` is not the zero address, and not equal to `from`,
            // check if it is approved to manage all the tokens of `from`.
            let by_ := shl(96, by)
            if iszero(or(iszero(by_), eq(by_, from_))) {
                mstore(0x00, by)
                if iszero(sload(keccak256(0x0c, 0x34))) {
                    mstore(0x00, 0x4b6e7f18) // `NotOwnerNorApproved()`.
                    revert(0x1c, 0x04)
                }
            }
            // Loop through all the `ids` and update the balances.
            {
                for { let i := shl(5, mload(ids)) } i { i := sub(i, 0x20) } {
                    let amount := mload(add(amounts, i))
                    // Decrease and store the updated balance of `from`.
                    {
                        mstore(0x00, mload(add(ids, i)))
                        let fromBalanceSlot := keccak256(0x00, 0x40)
                        let fromBalance := sload(fromBalanceSlot)
                        if gt(amount, fromBalance) {
                            mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.
                            revert(0x1c, 0x04)
                        }
                        sstore(fromBalanceSlot, sub(fromBalance, amount))
                    }
                }
            }
            // Emit a {TransferBatch} event.
            {
                let m := mload(0x40)
                // Copy the `ids`.
                mstore(m, 0x40)
                let n := add(0x20, shl(5, mload(ids)))
                let o := add(m, 0x40)
                pop(staticcall(gas(), 4, ids, n, o, n))
                // Copy the `amounts`.
                mstore(add(m, 0x20), add(0x40, returndatasize()))
                o := add(o, returndatasize())
                n := add(0x20, shl(5, mload(amounts)))
                pop(staticcall(gas(), 4, amounts, n, o, n))
                n := sub(add(o, returndatasize()), m)
                // Do the emit.
                log4(m, n, _TRANSFER_BATCH_EVENT_SIGNATURE, caller(), shr(96, from_), 0)
            }
        }
        if (_useAfterTokenTransfer()) {
            _afterTokenTransfer(from, address(0), ids, amounts, "");
        }
    }

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

    /// @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 {
            // Convert to 0 or 1.
            isApproved := iszero(iszero(isApproved))
            // Update the `isApproved` for (`by`, `operator`).
            mstore(0x20, _ERC1155_MASTER_SLOT_SEED)
            mstore(0x14, by)
            mstore(0x00, operator)
            sstore(keccak256(0x0c, 0x34), isApproved)
            // Emit the {ApprovalForAll} event.
            mstore(0x00, isApproved)
            let m := shr(96, not(0))
            log3(0x00, 0x20, _APPROVAL_FOR_ALL_EVENT_SIGNATURE, and(m, by), and(m, operator))
        }
    }

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

    /// @dev Equivalent to `_safeTransfer(address(0), from, to, id, amount, data)`.
    function _safeTransfer(address from, address to, uint256 id, uint256 amount, bytes memory data) internal virtual {
        _safeTransfer(address(0), from, to, id, amount, data);
    }

    /// @dev Transfers `amount` of `id` from `from` to `to`.
    ///
    /// Requirements:
    /// - `to` cannot be the zero address.
    /// - `from` must have at least `amount` of `id`.
    /// - If `by` is not the zero address, it must be either `from`,
    ///   or approved to manage the tokens of `from`.
    /// - If `to` refers to a smart contract, it must implement
    ///   {ERC1155-onERC1155Received}, which is called upon a batch transfer.
    ///
    /// Emits a {TransferSingle} event.
    function _safeTransfer(address by, address from, address to, uint256 id, uint256 amount, bytes memory data)
        internal
        virtual
    {
        if (_useBeforeTokenTransfer()) {
            _beforeTokenTransfer(from, to, _single(id), _single(amount), data);
        }
        /// @solidity memory-safe-assembly
        assembly {
            let from_ := shl(96, from)
            let to_ := shl(96, to)
            // Revert if `to` is the zero address.
            if iszero(to_) {
                mstore(0x00, 0xea553b34) // `TransferToZeroAddress()`.
                revert(0x1c, 0x04)
            }
            mstore(0x20, or(_ERC1155_MASTER_SLOT_SEED, from_))
            // If `by` is not the zero address, and not equal to `from`,
            // check if it is approved to manage all the tokens of `from`.
            let by_ := shl(96, by)
            if iszero(or(iszero(by_), eq(by_, from_))) {
                mstore(0x00, by)
                if iszero(sload(keccak256(0x0c, 0x34))) {
                    mstore(0x00, 0x4b6e7f18) // `NotOwnerNorApproved()`.
                    revert(0x1c, 0x04)
                }
            }
            // Subtract and store the updated balance of `from`.
            {
                mstore(0x00, id)
                let fromBalanceSlot := keccak256(0x00, 0x40)
                let fromBalance := sload(fromBalanceSlot)
                if gt(amount, fromBalance) {
                    mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.
                    revert(0x1c, 0x04)
                }
                sstore(fromBalanceSlot, sub(fromBalance, amount))
            }
            // Increase and store the updated balance of `to`.
            {
                mstore(0x20, or(_ERC1155_MASTER_SLOT_SEED, to_))
                let toBalanceSlot := keccak256(0x00, 0x40)
                let toBalanceBefore := sload(toBalanceSlot)
                let toBalanceAfter := add(toBalanceBefore, amount)
                if lt(toBalanceAfter, toBalanceBefore) {
                    mstore(0x00, 0x01336cea) // `AccountBalanceOverflow()`.
                    revert(0x1c, 0x04)
                }
                sstore(toBalanceSlot, toBalanceAfter)
            }
            // Emit a {TransferSingle} event.
            mstore(0x20, amount)
            // forgefmt: disable-next-line
            log4(0x00, 0x40, _TRANSFER_SINGLE_EVENT_SIGNATURE, caller(), shr(96, from_), shr(96, to_))
        }
        if (_useAfterTokenTransfer()) {
            _afterTokenTransfer(from, to, _single(id), _single(amount), data);
        }
        if (_hasCode(to)) _checkOnERC1155Received(from, to, id, amount, data);
    }

    /// @dev Equivalent to `_safeBatchTransfer(address(0), from, to, ids, amounts, data)`.
    function _safeBatchTransfer(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        _safeBatchTransfer(address(0), from, to, ids, amounts, data);
    }

    /// @dev Transfers `amounts` of `ids` from `from` to `to`.
    ///
    /// Requirements:
    /// - `to` cannot be the zero address.
    /// - `ids` and `amounts` must have the same length.
    /// - `from` must have at least `amounts` of `ids`.
    /// - If `by` is not the zero address, it must be either `from`,
    ///   or approved to manage the tokens of `from`.
    /// - If `to` refers to a smart contract, it must implement
    ///   {ERC1155-onERC1155BatchReceived}, which is called upon a batch transfer.
    ///
    /// Emits a {TransferBatch} event.
    function _safeBatchTransfer(
        address by,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        if (_useBeforeTokenTransfer()) {
            _beforeTokenTransfer(from, to, ids, amounts, data);
        }
        /// @solidity memory-safe-assembly
        assembly {
            if iszero(eq(mload(ids), mload(amounts))) {
                mstore(0x00, 0x3b800a46) // `ArrayLengthsMismatch()`.
                revert(0x1c, 0x04)
            }
            let from_ := shl(96, from)
            let to_ := shl(96, to)
            // Revert if `to` is the zero address.
            if iszero(to_) {
                mstore(0x00, 0xea553b34) // `TransferToZeroAddress()`.
                revert(0x1c, 0x04)
            }
            let fromSlotSeed := or(_ERC1155_MASTER_SLOT_SEED, from_)
            let toSlotSeed := or(_ERC1155_MASTER_SLOT_SEED, to_)
            mstore(0x20, fromSlotSeed)
            // If `by` is not the zero address, and not equal to `from`,
            // check if it is approved to manage all the tokens of `from`.
            let by_ := shl(96, by)
            if iszero(or(iszero(by_), eq(by_, from_))) {
                mstore(0x00, by)
                if iszero(sload(keccak256(0x0c, 0x34))) {
                    mstore(0x00, 0x4b6e7f18) // `NotOwnerNorApproved()`.
                    revert(0x1c, 0x04)
                }
            }
            // Loop through all the `ids` and update the balances.
            {
                for { let i := shl(5, mload(ids)) } i { i := sub(i, 0x20) } {
                    let amount := mload(add(amounts, i))
                    // Subtract and store the updated balance of `from`.
                    {
                        mstore(0x20, fromSlotSeed)
                        mstore(0x00, mload(add(ids, i)))
                        let fromBalanceSlot := keccak256(0x00, 0x40)
                        let fromBalance := sload(fromBalanceSlot)
                        if gt(amount, fromBalance) {
                            mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.
                            revert(0x1c, 0x04)
                        }
                        sstore(fromBalanceSlot, sub(fromBalance, amount))
                    }
                    // Increase and store the updated balance of `to`.
                    {
                        mstore(0x20, toSlotSeed)
                        let toBalanceSlot := keccak256(0x00, 0x40)
                        let toBalanceBefore := sload(toBalanceSlot)
                        let toBalanceAfter := add(toBalanceBefore, amount)
                        if lt(toBalanceAfter, toBalanceBefore) {
                            mstore(0x00, 0x01336cea) // `AccountBalanceOverflow()`.
                            revert(0x1c, 0x04)
                        }
                        sstore(toBalanceSlot, toBalanceAfter)
                    }
                }
            }
            // Emit a {TransferBatch} event.
            {
                let m := mload(0x40)
                // Copy the `ids`.
                mstore(m, 0x40)
                let n := add(0x20, shl(5, mload(ids)))
                let o := add(m, 0x40)
                pop(staticcall(gas(), 4, ids, n, o, n))
                // Copy the `amounts`.
                mstore(add(m, 0x20), add(0x40, returndatasize()))
                o := add(o, returndatasize())
                n := add(0x20, shl(5, mload(amounts)))
                pop(staticcall(gas(), 4, amounts, n, o, n))
                n := sub(add(o, returndatasize()), m)
                // Do the emit.
                log4(m, n, _TRANSFER_BATCH_EVENT_SIGNATURE, caller(), shr(96, from_), shr(96, to_))
            }
        }
        if (_useAfterTokenTransfer()) {
            _afterTokenTransfer(from, to, ids, amounts, data);
        }
        if (_hasCode(to)) _checkOnERC1155BatchReceived(from, to, ids, amounts, data);
    }

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

    /// @dev Override this function to return true if `_beforeTokenTransfer` is used.
    /// This is to help the compiler avoid producing dead bytecode.
    function _useBeforeTokenTransfer() internal view virtual returns (bool) {
        return false;
    }

    /// @dev Hook that is called before any token transfer.
    /// This includes minting and burning, as well as batched variants.
    ///
    /// The same hook is called on both single and batched variants.
    /// For single transfers, the length of the `id` and `amount` arrays are 1.
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {}

    /// @dev Override this function to return true if `_afterTokenTransfer` is used.
    /// This is to help the compiler avoid producing dead bytecode.
    function _useAfterTokenTransfer() internal view virtual returns (bool) {
        return false;
    }

    /// @dev Hook that is called after any token transfer.
    /// This includes minting and burning, as well as batched variants.
    ///
    /// The same hook is called on both single and batched variants.
    /// For single transfers, the length of the `id` and `amount` arrays are 1.
    function _afterTokenTransfer(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {}

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

    /// @dev Helper for calling the `_afterTokenTransfer` hook.
    /// This is to help the compiler avoid producing dead bytecode.
    function _afterTokenTransferCalldata(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) private {
        if (_useAfterTokenTransfer()) {
            _afterTokenTransfer(from, to, ids, amounts, data);
        }
    }

    /// @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 {IERC1155Receiver-onERC1155Received} on `to`.
    /// Reverts if the target does not support the function correctly.
    function _checkOnERC1155Received(address from, address to, uint256 id, uint256 amount, bytes memory data) private {
        /// @solidity memory-safe-assembly
        assembly {
            // Prepare the calldata.
            let m := mload(0x40)
            // `onERC1155Received(address,address,uint256,uint256,bytes)`.
            mstore(m, 0xf23a6e61)
            mstore(add(m, 0x20), caller())
            mstore(add(m, 0x40), shr(96, shl(96, from)))
            mstore(add(m, 0x60), id)
            mstore(add(m, 0x80), amount)
            mstore(add(m, 0xa0), 0xa0)
            let n := mload(data)
            mstore(add(m, 0xc0), n)
            if n { pop(staticcall(gas(), 4, add(data, 0x20), n, add(m, 0xe0), n)) }
            // Revert if the call reverts.
            if iszero(call(gas(), to, 0, add(m, 0x1c), add(0xc4, n), m, 0x20)) {
                if returndatasize() {
                    // Bubble up the revert if the call reverts.
                    returndatacopy(m, 0x00, returndatasize())
                    revert(m, returndatasize())
                }
            }
            // Load the returndata and compare it with the function selector.
            if iszero(eq(mload(m), shl(224, 0xf23a6e61))) {
                mstore(0x00, 0x9c05499b) // `TransferToNonERC1155ReceiverImplementer()`.
                revert(0x1c, 0x04)
            }
        }
    }

    /// @dev Perform a call to invoke {IERC1155Receiver-onERC1155BatchReceived} on `to`.
    /// Reverts if the target does not support the function correctly.
    function _checkOnERC1155BatchReceived(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) private {
        /// @solidity memory-safe-assembly
        assembly {
            // Prepare the calldata.
            let m := mload(0x40)
            // `onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)`.
            mstore(m, 0xbc197c81)
            mstore(add(m, 0x20), caller())
            mstore(add(m, 0x40), shr(96, shl(96, from)))
            // Copy the `ids`.
            mstore(add(m, 0x60), 0xa0)
            let n := add(0x20, shl(5, mload(ids)))
            let o := add(m, 0xc0)
            pop(staticcall(gas(), 4, ids, n, o, n))
            // Copy the `amounts`.
            let s := add(0xa0, returndatasize())
            mstore(add(m, 0x80), s)
            o := add(o, returndatasize())
            n := add(0x20, shl(5, mload(amounts)))
            pop(staticcall(gas(), 4, amounts, n, o, n))
            // Copy the `data`.
            mstore(add(m, 0xa0), add(s, returndatasize()))
            o := add(o, returndatasize())
            n := add(0x20, mload(data))
            pop(staticcall(gas(), 4, data, n, o, n))
            n := sub(add(o, returndatasize()), add(m, 0x1c))
            // Revert if the call reverts.
            if iszero(call(gas(), to, 0, add(m, 0x1c), n, m, 0x20)) {
                if returndatasize() {
                    // Bubble up the revert if the call reverts.
                    returndatacopy(m, 0x00, returndatasize())
                    revert(m, returndatasize())
                }
            }
            // Load the returndata and compare it with the function selector.
            if iszero(eq(mload(m), shl(224, 0xbc197c81))) {
                mstore(0x00, 0x9c05499b) // `TransferToNonERC1155ReceiverImplementer()`.
                revert(0x1c, 0x04)
            }
        }
    }

    /// @dev Returns `x` in an array with a single element.
    function _single(uint256 x) private pure returns (uint256[] memory result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := mload(0x40)
            mstore(0x40, add(result, 0x40))
            mstore(result, 1)
            mstore(add(result, 0x20), x)
        }
    }
}

{
  "remappings": [
    "forge-std/=lib/forge-std/src/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "paris",
  "viaIR": true,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"originalAddress","type":"address"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"string","name":"baseURI","type":"string"},{"internalType":"string","name":"extension","type":"string"},{"internalType":"address","name":"royaltyRecipient","type":"address"},{"internalType":"uint256","name":"royaltyBps","type":"uint256"}],"name":"deployERC721","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"originalAddress","type":"address"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"string","name":"baseURI","type":"string"},{"internalType":"string","name":"extension","type":"string"},{"internalType":"address","name":"royaltyRecipient","type":"address"},{"internalType":"uint256","name":"royaltyBps","type":"uint256"}],"name":"deployERC721Enumerable","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"nonpayable","type":"function"}]

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