Token

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

import {ERC721, ERC721TokenReceiver} from "solmate/tokens/ERC721.sol";
import {Owned} from "solmate/auth/Owned.sol";
import {IAdoptAHyphen} from "./interfaces/IAdoptAHyphen.sol";
import {IERC721} from "./interfaces/IERC721.sol";
import {AdoptAHyphenArt} from "./utils/AdoptAHyphenArt.sol";
import {AdoptAHyphenMetadata} from "./utils/AdoptAHyphenMetadata.sol";
import {Base64} from "./utils/Base64.sol";

/// @title adopt-a-hyphen
/// @notice Adopt a Hyphen: exchange a Hyphen NFT into this contract to mint a
/// Hyphen Guy.
contract AdoptAHyphen is IAdoptAHyphen, ERC721, ERC721TokenReceiver, Owned {
    // -------------------------------------------------------------------------
    // Constants
    // -------------------------------------------------------------------------

    /// @notice Description of the collection.
    string constant COLLECTION_DESCRIPTION =
        unicode"With each passing day, more and more people are switching from "
        unicode"“on-chain” to “onchain.” While this may seem like a harmless ch"
        unicode"oice, thousands of innocent hyphens are losing their place in t"
        unicode"he world. No longer needed to hold “on-chain” together, these h"
        unicode"yphens are in need of a loving place to call home. What if you "
        unicode"could make a difference in a hyphen’s life forever?\\n\\nIntrod"
        unicode"ucing the Adopt-a-Hyphen program, where you can adopt a hyphen "
        unicode"and give it a new home...right in your wallet! Each hyphen in t"
        unicode"his collection was adopted via an on-chain mint and is now safe"
        unicode" and sound in this collection. As is their nature, each hyphen "
        unicode"lives fully on-chain and is rendered in Solidity as cute, gener"
        unicode"ative ASCII art.";

    // -------------------------------------------------------------------------
    // Immutable storage
    // -------------------------------------------------------------------------

    /// @notice The Hyphen NFT contract that must be transferred into this
    /// contract in order to mint a token.
    IERC721 public immutable override hyphenNft;

    // -------------------------------------------------------------------------
    // Constructor + Mint
    // -------------------------------------------------------------------------

    /// @param _owner Initial owner of the contract.
    constructor(
        address _hyphenNft,
        address _owner
    ) ERC721("Adopt-a-Hyphen", "-") Owned(_owner) {
        hyphenNft = IERC721(_hyphenNft);
    }

    /// @inheritdoc IAdoptAHyphen
    function mint(uint256 _tokenId) external {
        // Transfer the Hyphen NFT into this contract.
        hyphenNft.transferFrom(msg.sender, address(this), _tokenId);

        // Mint token.
        _mint(msg.sender, _tokenId);
    }

    // -------------------------------------------------------------------------
    // ERC721Metadata
    // -------------------------------------------------------------------------

    /// @inheritdoc ERC721
    function tokenURI(
        uint256 _tokenId
    ) public view override returns (string memory) {
        // Revert if the token hasn't been minted.
        if (_ownerOf[_tokenId] == address(0)) revert TokenUnminted();

        // Seed to generate the art and metadata from.
        uint256 seed = uint256(keccak256(abi.encodePacked(_tokenId)));

        // Generate the metadata.
        string memory name = AdoptAHyphenMetadata.generateName(seed);
        string memory attributes = AdoptAHyphenMetadata.generateAttributes(
            seed
        );

        return
            string.concat(
                "data:application/json;base64,",
                Base64.encode(
                    abi.encodePacked(
                        '{"name":"',
                        name,
                        '","description":"',
                        COLLECTION_DESCRIPTION,
                        '","image_data":"data:image/svg+xml;base64,',
                        Base64.encode(
                            abi.encodePacked(AdoptAHyphenArt.render(seed))
                        ),
                        '","attributes":',
                        attributes,
                        "}"
                    )
                )
            );
    }

    // -------------------------------------------------------------------------
    // Contract metadata
    // -------------------------------------------------------------------------

    /// @inheritdoc IAdoptAHyphen
    function contractURI() external pure override returns (string memory) {
        return
            string.concat(
                "data:application/json;base64,",
                Base64.encode(
                    abi.encodePacked(
                        '{"name":"Adopt-a-Hyphen","description":"',
                        COLLECTION_DESCRIPTION,
                        '"}'
                    )
                )
            );
    }
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;

/// @notice Modern, minimalist, and gas efficient ERC-721 implementation.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC721.sol)
abstract contract ERC721 {
    /*//////////////////////////////////////////////////////////////
                                 EVENTS
    //////////////////////////////////////////////////////////////*/

    event Transfer(address indexed from, address indexed to, uint256 indexed id);

    event Approval(address indexed owner, address indexed spender, uint256 indexed id);

    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /*//////////////////////////////////////////////////////////////
                         METADATA STORAGE/LOGIC
    //////////////////////////////////////////////////////////////*/

    string public name;

    string public symbol;

    function tokenURI(uint256 id) public view virtual returns (string memory);

    /*//////////////////////////////////////////////////////////////
                      ERC721 BALANCE/OWNER STORAGE
    //////////////////////////////////////////////////////////////*/

    mapping(uint256 => address) internal _ownerOf;

    mapping(address => uint256) internal _balanceOf;

    function ownerOf(uint256 id) public view virtual returns (address owner) {
        require((owner = _ownerOf[id]) != address(0), "NOT_MINTED");
    }

    function balanceOf(address owner) public view virtual returns (uint256) {
        require(owner != address(0), "ZERO_ADDRESS");

        return _balanceOf[owner];
    }

    /*//////////////////////////////////////////////////////////////
                         ERC721 APPROVAL STORAGE
    //////////////////////////////////////////////////////////////*/

    mapping(uint256 => address) public getApproved;

    mapping(address => mapping(address => bool)) public isApprovedForAll;

    /*//////////////////////////////////////////////////////////////
                               CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/

    constructor(string memory _name, string memory _symbol) {
        name = _name;
        symbol = _symbol;
    }

    /*//////////////////////////////////////////////////////////////
                              ERC721 LOGIC
    //////////////////////////////////////////////////////////////*/

    function approve(address spender, uint256 id) public virtual {
        address owner = _ownerOf[id];

        require(msg.sender == owner || isApprovedForAll[owner][msg.sender], "NOT_AUTHORIZED");

        getApproved[id] = spender;

        emit Approval(owner, spender, id);
    }

    function setApprovalForAll(address operator, bool approved) public virtual {
        isApprovedForAll[msg.sender][operator] = approved;

        emit ApprovalForAll(msg.sender, operator, approved);
    }

    function transferFrom(
        address from,
        address to,
        uint256 id
    ) public virtual {
        require(from == _ownerOf[id], "WRONG_FROM");

        require(to != address(0), "INVALID_RECIPIENT");

        require(
            msg.sender == from || isApprovedForAll[from][msg.sender] || msg.sender == getApproved[id],
            "NOT_AUTHORIZED"
        );

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        unchecked {
            _balanceOf[from]--;

            _balanceOf[to]++;
        }

        _ownerOf[id] = to;

        delete getApproved[id];

        emit Transfer(from, to, id);
    }

    function safeTransferFrom(
        address from,
        address to,
        uint256 id
    ) public virtual {
        transferFrom(from, to, id);

        require(
            to.code.length == 0 ||
                ERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, "") ==
                ERC721TokenReceiver.onERC721Received.selector,
            "UNSAFE_RECIPIENT"
        );
    }

    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        bytes calldata data
    ) public virtual {
        transferFrom(from, to, id);

        require(
            to.code.length == 0 ||
                ERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, data) ==
                ERC721TokenReceiver.onERC721Received.selector,
            "UNSAFE_RECIPIENT"
        );
    }

    /*//////////////////////////////////////////////////////////////
                              ERC165 LOGIC
    //////////////////////////////////////////////////////////////*/

    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return
            interfaceId == 0x01ffc9a7 || // ERC165 Interface ID for ERC165
            interfaceId == 0x80ac58cd || // ERC165 Interface ID for ERC721
            interfaceId == 0x5b5e139f; // ERC165 Interface ID for ERC721Metadata
    }

    /*//////////////////////////////////////////////////////////////
                        INTERNAL MINT/BURN LOGIC
    //////////////////////////////////////////////////////////////*/

    function _mint(address to, uint256 id) internal virtual {
        require(to != address(0), "INVALID_RECIPIENT");

        require(_ownerOf[id] == address(0), "ALREADY_MINTED");

        // Counter overflow is incredibly unrealistic.
        unchecked {
            _balanceOf[to]++;
        }

        _ownerOf[id] = to;

        emit Transfer(address(0), to, id);
    }

    function _burn(uint256 id) internal virtual {
        address owner = _ownerOf[id];

        require(owner != address(0), "NOT_MINTED");

        // Ownership check above ensures no underflow.
        unchecked {
            _balanceOf[owner]--;
        }

        delete _ownerOf[id];

        delete getApproved[id];

        emit Transfer(owner, address(0), id);
    }

    /*//////////////////////////////////////////////////////////////
                        INTERNAL SAFE MINT LOGIC
    //////////////////////////////////////////////////////////////*/

    function _safeMint(address to, uint256 id) internal virtual {
        _mint(to, id);

        require(
            to.code.length == 0 ||
                ERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, "") ==
                ERC721TokenReceiver.onERC721Received.selector,
            "UNSAFE_RECIPIENT"
        );
    }

    function _safeMint(
        address to,
        uint256 id,
        bytes memory data
    ) internal virtual {
        _mint(to, id);

        require(
            to.code.length == 0 ||
                ERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, data) ==
                ERC721TokenReceiver.onERC721Received.selector,
            "UNSAFE_RECIPIENT"
        );
    }
}

/// @notice A generic interface for a contract which properly accepts ERC721 tokens.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC721.sol)
abstract contract ERC721TokenReceiver {
    function onERC721Received(
        address,
        address,
        uint256,
        bytes calldata
    ) external virtual returns (bytes4) {
        return ERC721TokenReceiver.onERC721Received.selector;
    }
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;

/// @notice Simple single owner authorization mixin.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/Owned.sol)
abstract contract Owned {
    /*//////////////////////////////////////////////////////////////
                                 EVENTS
    //////////////////////////////////////////////////////////////*/

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

    /*//////////////////////////////////////////////////////////////
                            OWNERSHIP STORAGE
    //////////////////////////////////////////////////////////////*/

    address public owner;

    modifier onlyOwner() virtual {
        require(msg.sender == owner, "UNAUTHORIZED");

        _;
    }

    /*//////////////////////////////////////////////////////////////
                               CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/

    constructor(address _owner) {
        owner = _owner;

        emit OwnershipTransferred(address(0), _owner);
    }

    /*//////////////////////////////////////////////////////////////
                             OWNERSHIP LOGIC
    //////////////////////////////////////////////////////////////*/

    function transferOwnership(address newOwner) public virtual onlyOwner {
        owner = newOwner;

        emit OwnershipTransferred(msg.sender, newOwner);
    }
}

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

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

/// @title The interface for {AdoptAHyphen}
interface IAdoptAHyphen {
    // -------------------------------------------------------------------------
    // Errors
    // -------------------------------------------------------------------------

    /// @notice Emitted when a token hasn't been minted.
    error TokenUnminted();

    // -------------------------------------------------------------------------
    // Immutable storage
    // -------------------------------------------------------------------------

    /// @return The Hyphen NFT contract.
    function hyphenNft() external view returns (IERC721);

    // -------------------------------------------------------------------------
    // Functions
    // -------------------------------------------------------------------------

    /// @notice Mints a token to the sender in exchange for the hyphen NFT (the
    /// NFT gets transferred into this contract, and it can never be transferred
    /// out).
    /// @dev `msg.sender` must have approvals set to `true` on the hyphen NFT
    /// with the operator as this contract's address.
    function mint(uint256 _tokenId) external;

    // -------------------------------------------------------------------------
    // Metadata
    // -------------------------------------------------------------------------

    /// @return The contract URI for this contract.
    function contractURI() external view returns (string memory);
}

// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.17;

interface IERC721 {
    function safeTransferFrom(
        address _from,
        address _to,
        uint256 _tokenId
    ) external payable;

    function transferFrom(
        address _from,
        address _to,
        uint256 _tokenId
    ) external;

    function ownerOf(uint256 _tokenId) external view returns (address);
}

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

import {LibPRNG} from "solady/utils/LibPRNG.sol";
import {LibString} from "solady/utils/LibString.sol";

/// @title Adopt-a-Hyphen art
/// @notice A library for generating SVGs for {AdoptAHyphen}.
/// @dev For this library to be correct, all `_seed` values must be consistent
/// with every function in both {AdoptAHyphenArt} and {AdoptAHyphenMetadata}.
library AdoptAHyphenArt {
    using LibPRNG for LibPRNG.PRNG;
    using LibString for uint256;

    // -------------------------------------------------------------------------
    // Structs
    // -------------------------------------------------------------------------

    /// @notice The traits that make up a Hyphen Guy.
    /// @param head Head trait, a number in `[0, 3]`. Equal chances.
    /// @param eye Eye trait, a number in `[0, 16]`. Equal chances.
    /// @param hat Hat trait, a number in `[0, 14]`. 25% chance of being `0`,
    /// which indicates no hat trait. Equal chances amongst the other hats.
    /// @param arm Arm trait, a number in `[0, 4]`. Equal chances.
    /// @param body Body trait, a number in `[0, 2]`. Equal chances.
    /// @param chest Chest trait, a number in `[0, 4]`. 50% chance of being `0`,
    /// which indicates no chest trait. Equal chances amongst the other chests.
    /// @param leg Leg trait, a number in `[0, 3]`. Equal chances.
    /// @param background Background trait, a number in `[0, 8]`. Equal chances.
    /// @param chaosBg Whether the background is made up of multiple background
    /// characters, or just 1. 25% chance of being true.
    /// @param intensity Number of positions (out of 253 (`23 * 11`)) to fill
    /// with a background character, a number in `[50, 200]`. 25% chance of
    /// being `252`, which indicates no variable intensity (every empty position
    /// would be filled). Equal chances amongst the other intensities.
    struct HyphenGuy {
        uint8 head;
        uint8 eye;
        uint8 hat;
        uint8 arm;
        uint8 body;
        uint8 chest;
        uint8 leg;
        uint8 background;
        bool chaosBg;
        uint8 intensity;
        bool inverted;
        uint8 color;
    }

    // -------------------------------------------------------------------------
    // Constants
    // -------------------------------------------------------------------------

    /// @notice Starting string for the SVG.
    /// @dev The `line-height` attribute for `pre` elements is set to `51px`
    /// because we want to fit in 11 lines into a `600 - 32 * 2 + 12` = 548px
    /// tall container. At 32px, the Martian Mono Extra Bold font has a width of
    /// 22.4px and a height of 38.5px. Additionally, we want to fit 11 lines
    /// with 23 characters each into a 600px square container with 32px padding
    /// on each side. Martian Mono comes with an overhead of 12px above each
    /// character, and 0px on either side, so effectively, we want to fit in
    /// `22.4px/character * 11 characters` into a `600 - 32 * 2 + 12` = 548px
    /// tall container, and `38.5px/character * 23 characters` into a
    /// `600 - 32 * 2` = 536px wide container. Therefore, we calculate 51px for
    /// the `line-height` property:
    /// `38.5 + (548 - 38.5 * 11) / (11 - 1) = 50.95 ≈ 51`. We round to `51`
    /// because Safari doesn't support decimal values for `line-height`, so
    /// technically, the text is off by `0.05 * 23` = 1.15px. Similarly, we
    /// calculate 0.945 for the `letter-spacing` property:
    /// `(536 - 23 * 22.4) / 22 ≈ 0.945`. We set these properties on the `pre`
    /// element.
    string constant SVG_START =
        '<svg xmlns="http://www.w3.org/2000/svg" width="600" height="600" viewB'
        'ox="0 0 600 600"><style>@font-face{font-family:A;src:url(data:font/wof'
        "f2;utf-8;base64,d09GMgABAAAAAAv4ABAAAAAAGGQAAAuXAAEAAAAAAAAAAAAAAAAAAA"
        "AAAAAAAAAAGmQbgRochHYGYD9TVEFUQACBehEICptclWcLgQgAATYCJAOCDAQgBYQoByAM"
        "BxvRE1FUkhZI9pFQ3b6KeSApp0iMMYLk/3x42lbvDwPoDOEKRo+FkYQNRmNyu9BGrmIWG1"
        "yU67Xb7Zbu9kWEXkXB898f5rl/S00MM14AS2/gS0sYwAhFMGDJ8/9be7VzM4H95UlYFkH4"
        "ClXn3s7fPyez86fAH0qwwQ0QHN9EtcJVSCBSRC7CJL4sXI2rELbbUj0JE5LtEZwpUw6rCt"
        "5d8/FrXxoERQIAACMKi6AQNG8Eq7R4LYhQQYQLghOEWhCZgtAJosjwxClApPIIPDkjhgq1"
        "Wl5jhOSudWwAEjQAHzyyy6vBC0AMHdDEWUiI+C5Mlo2gKNpD9bG1Ei/eWKg1YCEBMlepCS"
        "xohvAAIGkKSGsze7VppS3Cl6Qtg6wUGTkE9w981Z6kWQLDM9MXnLb2jUFxNjDYj+T/ovAS"
        "UN0NtvdB+zDeP4Lil4mRAVQCCKEFsTyhVEaCHOU+Vil/oAgSRvdmBSfIargbz5PL5HnkgT"
        "ktoeCREoL67VQiyk38TaDqAhRGFBO+trg98A8QAb6sRAjIxaqRstjmP3xYOT/+BAABXwq5"
        "6vS5YY05u3hIAV4utNjDtdwbHZjl8ZyBHBPcIFhUOcFAACo9BWbqlAJED2Bbf6GINmS9EB"
        "AjJqaP1RJSPn3/OyhyQjHiaOnkK1CIEAoTSyNTlmw5I40QVhNhBK5NPICGwLMTAamER42M"
        "UFz6KGp0+77DgQ/UjLICqFa/mhxAlW6AmsC7AQAN4EnlH55+J3gYnEu8Lysb6GX8DdgKAN"
        "QWjwPA4SHjTAFyy2Ie5bNjrJsQYPKye4wABO0BuRkVEToABAEykhsIDE9K1hAjaJ9/FQUO"
        "TSBJOpUsufIVKVGlRj0jq2aDpmxwyeMBcFJwhFYhKnkdd2TN1IXnvXqrPjm9/EN1ra7Wlb"
        "pQi+DZVfPg6UYoaAEA4vRIZ2WaletfGyJcqkhqeZTSxEvA0YgVKopEtkxZ0hHJoqXIpSCW"
        "SCVJDoKUhxQAlACAWwDogTcH+EsA7gWwCwAAUIgeTtkM3vBC5RYDiIM6Ax/NiAnjFKooPS"
        "3IZj4zCs15QzpUJPIXSJKQl6+PyFe0oAotXLs32EukfX7KaeHj438eLy86UZRH08kiRVd+"
        "cD33fm7lmVmXeJppYhrMRIzW2evk+jfYTSsrJub1H2Z2Ge4VcvANC7ucXoMVshTLYwUMj6"
        "FYciphiBSST5oosdgrbV4jPBGR0m5mS1oMdiBuZO2qWtTE2KjIIbiXzZveuMSi7xDz49xP"
        "l3XYWZOJtVhYq40xmxmjkS211FL31FFmfhgb8U2FM6HGZinVAjFJp52I2mlm7kLHbvu1xy"
        "rs1RMvc8wbN95uNMpm/tnA9BIRkbqmGFeXnC2xRXZ2w3NmC4yHlqMn2Q7nWKCbeMmMCAvR"
        "p5FxgIm49bCLpRnb7KsQf42Wtq/2mkwte9K++XSSrLazVs0sskktLha2SCFZk3Svi53W/n"
        "LH0ya8/lActbjIikkayRvaC8n2d4BxZJ2URYC6LjlsJiw2kkEydTpuApPglinBAcIi0i91"
        "gemzEI1cYi8RYYWMi7Uyj0hDUGPCnGVGueeuSvZpOfump+Jw6HHHhCkBmZMvPUSuP7Ge9j"
        "G4t28PcjJrTy8eeHpLXzah5x+G+/gVGn/jWbd1uVX7giJk3/0Cu+klXvpBhTmO9yx19rzK"
        "nk8/EGuaDiIUCJnbCUPYjKGcgYNIDYZewkLaSRvppwYHeINoQWv77LMPnj7BzC6EPoYHn3"
        "ng1HH7G89EsMvLDgdrY+ys1UJG0fAiYDvZDrZtx/Yexxu7MYFhAypy4CIspopB63XgxzzG"
        "5cKUuv/WLfLZLXHvLt64iB7Z9r0rL754aGWX/Xq9fhO/bUFckV+mLi6e2bBBN1OQllcoKV"
        "7gN1fdsqECWu7+vOfz7ufuVz+vhnbp8auPL5Wa94wqmd1dUrrear1syqpSaaqy2g3nRcHW"
        "svU3lOAG7v5+/RKyuKgb5uSsvmT/ohyNsj2H2rV7DsndJ0rbJLSl+PJA/wdLM0sf9CPu5M"
        "2Xtj/d8xdTLWeq+/+6dnn7ws3PNL1zfY3md9Aoa7i1Xj/fuVZ/HxQ3NN5SX7y2Uz8fbtid"
        "X2y/7roika8rAYK3A9XOhCNFD3U9tUN+wvnU+SO5O9Mfs57eKd9pP43GXvj3H5EP7FwMtH"
        "MnXVcO5D2Yf0rU00kntzhj01TK9K+OLPLt+g3XF9kc7sKySaPF4W5VHjLJDUsKtPj+5vtS"
        "jFXuXuKQeCMXGc3doDZA47K1fdLptNbDOSzrglrU6pagwCEbGnKovzhjUJ8LT8zdlVGRvc"
        "rnI5FEnnEHXdvSUFPrWF2mrSirChiNDv7fVQDB2xv/3nHeHLe8LgeNbHF5eXGJ4mX3BB8e"
        "d7/f/Y1y3d+ZWX/rtIW5WZnFtfBs4sYPfatr6dMPObvu6lJ0InJvxsj/NJnHvukJrcS5UL"
        "IYSviOooSEKnRHCwRGc96vcdsLe+uh5sajpftKM+6at4BCZvA7+PcCHgZ/yYDnWkCsTDMd"
        "O/DyI48Awbn33Si/vL35v5Mnm/+/vO1yGIIlTVVsa/5/wX+Xt2/eV/MZoPgl0cSrS1eGyS"
        "rjCvTGan+fRWsNvzxTtb5WhWLm9Mbj5N99x6nTG2YU9GCYujzD38y66FPtpzcWYnN9mLIu"
        "DfRricE8cnpjvqo8k/mXFMTJKkPp/Haria51CWWYTK8o1Bur/W4/J0N9DxuOU4iVnd3xmO"
        "axHePdECydtf44+d+A9DHD4yGn5jDy1ODW8bqPDx+u/3j7+OBt922787P96TH2guKi2Tvv"
        "LJotLrDHlOhKdW0d589d7r6/M8Ir56a8TZqRkIGa2v6QkP7amgGs8i3uysptytfF2nTF+v"
        "Sq+CcdYf4VMrk9UOL6bt8a4TNBC2Pfvx2h09ialIU6W6rSmKuJrJ0pTi1OWMeP8UuL9FfX"
        "Faqmhau3eTUU7ukYcxdBlrdtfhui2r+c+/KBkgtHUpWuuBDjr12SHp9R91pD+cgN+Q7Hjb"
        "rKcXrN2Yc+VGl2BTJ/e6JOQ9mIW2e33ZCt76drIOa++25ffh1w4n0z+2Dbss9rn3CVCaNe"
        "cuzsLjnUPBbytAi9EkvgOY+Ah1+L1XeuHPeRzReNC53Woap5nnxeGULJj4vFr2Lx4j1+hg"
        "sj+Cb3zZvd51KNzc1G7axpYsZ2a+akv8hkv0jN5queGGPE6sAE9BY23dJX7T8wN+D12Iwd"
        "wuG3EAgRCPzPbbKCeHAgQCDmkQcheFUFQgEI02RYAEbmybLr51iJDMBvM+RtM6Ci40gjrZ"
        "yiIM1WwMM0rjKZlmexnFfQFSK05MkFNvSkFCTfABzw/NaCySUsAdSiwYt7B2TB5xCnw0ty"
        "yJgL7EWCc/A4rHh+zRdtCiJEyIIiqNvwVZGRUDvJaadSt3lepCjc8EOdOUBZeAbHmnugXm"
        "B3iWqjnDAoan3UBxCJYCoEe75KKv5pRSAAAo9rtno3S7W/efF4XwLwzhc/bAaADz69acjz"
        "wv8vPD5tBiBAAQACvz32gvoNOH/GSUCkQUm7H9oCflBlaZGEG5CFEBt5QDribBOFFkU4gK"
        "XRXryMJgfArhT2I7Thsa0D7QpVgPPoxRbU2ncBnfgXYSwlQuTDcyWwDzcgSscM8ZeA56vz"
        "5SKAEnWE0OvDZHm/cf3ZU4euN4AFwCwlki0spUi8uZSn0OfD6fBSvuAolggkprABAUTpga"
        "UETCaWesM3bi2Ch78XJQYNmTbCqUu3MRyV9CLBMTrorFmr1YgxTLUaWOvBw8qDOAYj5T06"
        "tcsSRcZBd7t1R4zixMcjo4dI21xp0nRxBn/3uDap2g3ql6bTBKc+/a3oUa/t34w3oQeJMl"
        "M+jNy82KA+HVbr1GVcH79cKVV6FuSpU28mK5MXS802lgKzHItxhodxarDksKiHly4LnTqM"
        "9cExdQ+bfAj+oD48AADPLioAkda+TDw3f9F3AAAAAA==)}pre{font-family:A;font-s"
        "ize:32px;text-align:center;margin:0;letter-spacing:0.945px;line-height"
        ":51px}@supports (color:color(display-p3 1 1 1)){.z{color:oklch(79.59% "
        "0.042 250.64)!important}.y{color:oklch(60.59% 0.306 309.33)!important}"
        ".x{color:oklch(69.45% 0.219 157.46)!important}.w{color:oklch(75.22% 0."
        "277 327.48)!important}.v{color:oklch(77.86% 0.16 226.017)!important}.u"
        "{color:oklch(74.3% 0.213 50.613)!important}.t{color:oklch(61.52% 0.224"
        " 256.099)!important}.s{color:oklch(62.61% 0.282 29.234)!important}}</s"
        "tyle><path ";

    /// @notice Ending string for the SVG.
    string constant SVG_END = "</pre></foreignObject></svg>";

    /// @notice Characters corresponding to the `head` trait's left characters.
    bytes32 constant HEADS_LEFT = "|[({";

    /// @notice Characters corresponding to the `head` trait's right characters.
    bytes32 constant HEADS_RIGHT = "|])}";

    /// @notice Characters corresponding to the `eye` trait's characters.
    bytes32 constant EYES = "\"#$'*+-.0=OTX^oxz";

    /// @notice Characters corresponding to the `hat` trait's characters.
    /// @dev An index of 0 corresponds to no hat trait, so the character at
    /// index 0 can be anything, but we just made it a space here.
    /// @dev If the hat character is `&` (i.e. index of `5`), then it must be
    /// drawn in its entity form, i.e. `&amp;`.
    bytes32 constant HATS = " !#$%&'*+-.=@^~";

    /// @notice Characters corresponding to the `arm` trait's left characters.
    /// @dev If the arm character is `<` (i.e. index of `1`), then it must be
    /// drawn in its entity form, i.e. `&lt;`.
    bytes32 constant ARMS_LEFT = "/<~J2";

    /// @notice Characters corresponding to the `arm` trait's right characters.
    /// @dev If the arm character is `>` (i.e. index of `1`), then it must be
    /// drawn in its entity form, i.e. `&gt;`.
    bytes32 constant ARMS_RIGHT = "\\>~L7";

    /// @notice Characters corresponding to the `body` trait's left characters.
    bytes32 constant BODIES_LEFT = "[({";

    /// @notice Characters corresponding to the `body` trait's right characters.
    bytes32 constant BODIES_RIGHT = "])}";

    /// @notice Characters corresponding to the `chest` trait's characters.
    /// @dev An index of 0 corresponds to no chest trait, so the character at
    /// index 0 can be anything, but we just made it a space here.
    bytes32 constant CHESTS = "  :*=.";

    /// @notice Characters corresponding to the `leg` trait's left characters.
    bytes32 constant LEGS_LEFT = "|/|/";

    /// @notice Characters corresponding to the `leg` trait's right characters.
    bytes32 constant LEGS_RIGHT = "||\\\\";

    /// @notice Characters corresponding to the `background` trait's characters.
    /// @dev If the background character is `\` (i.e. index of `6`), then it
    /// must be escaped properly in JSONs, i.e. `\\\\`.
    bytes32 constant BACKGROUNDS = "#*+-/=\\|.";

    /// @notice Characters for the last few characters in the background that
    /// spell out ``CHAIN''.
    /// @dev The character at index 0 can be anything, but we just made it `N`
    /// here.
    bytes32 constant CHAIN_REVERSED = "NIAHC";

    /// @notice Bitpacked integer of 32-bit words containing 24-bit colors.
    /// @dev The first 8 bits in each word are unused, but we made each word
    /// 32-bit so we can calculate the bit index via `<< 5`, rather than `* 24`.
    uint256 constant COLORS =
        0xA9BFD700AD43ED0000BA7300FE63FF0000C9FF00FF8633000080FF00FE0000;

    /// @notice Utility string for converting targetting classes that provide
    /// p3 color support (see classes `s` through `z` in `SVG_START`'s `<style>`
    /// block).
    bytes32 constant COLOR_CLASSES = "stuvwxyz";

    // -------------------------------------------------------------------------
    // `render`
    // -------------------------------------------------------------------------

    /// @notice Renders a Hyphen Guy SVG.
    /// @param _seed Seed to select traits for the Hyphen Guy.
    /// @return SVG string representing the Hyphen Guy.
    function render(uint256 _seed) internal pure returns (string memory) {
        // Initialize PRNG.
        LibPRNG.PRNG memory prng = LibPRNG.PRNG(_seed);

        // The Hyphen Guy.
        HyphenGuy memory hyphenGuy;

        // Select traits from `prng`.
        hyphenGuy.head = uint8(prng.state & 3); // 4 heads (2 bits)
        prng.state >>= 2;
        hyphenGuy.eye = uint8(prng.state % 17); // 17 eyes (5 bits)
        prng.state >>= 5;
        hyphenGuy.hat = uint8( // 25% chance + 14 hats (2 + 4 = 6 bits)
            prng.state & 3 == 0 ? 0 : 1 + ((prng.state >> 2) % 14)
        );
        prng.state >>= 6;
        hyphenGuy.arm = uint8(prng.state % 5); // 5 arms (3 bits)
        prng.state >>= 3;
        hyphenGuy.body = uint8(prng.state % 3); // 3 bodies (2 bits)
        prng.state >>= 2;
        hyphenGuy.chest = uint8(
            prng.state & 1 == 0 ? 0 : 1 + ((prng.state >> 1) % 5)
        ); // 50% chance + 5 chests (1 + 3 = 4 bits)
        prng.state >>= 4;
        hyphenGuy.leg = uint8(prng.state & 3); // 4 legs (2 bits)
        prng.state >>= 2;
        hyphenGuy.background = uint8(prng.state % 9); // 9 backgrounds (4 bits)
        prng.state >>= 4;
        hyphenGuy.chaosBg = prng.state & 3 == 0; // 25% chance (2 bits)
        prng.state >>= 2;
        hyphenGuy.intensity = uint8(
            prng.state & 3 == 0 ? 50 + ((prng.state >> 2) % 151) : 252
        ); // 25% chance + 151 intensities (2 + 8 = 10 bits)
        prng.state >>= 10;
        hyphenGuy.inverted = prng.state & 7 == 0; // 12.5% chance (3 bits)
        prng.state >>= 3;
        hyphenGuy.color = uint8(prng.state & 7); // 8 colors (3 bits)

        // Get the next state in the PRNG.
        prng.state = prng.next();

        // `bitmap` has `0`s where the index corresponds to a Hyphen Guy
        // character, and `1` where not. We use this to determine whether to
        // render a Hyphen Guy character or a background character. i.e. it
        // looks like the following:
        //                        11111111111111111111111
        //                        11111111111111111111111
        //                        11111111111111111111111
        //                        11111111111111111111111
        //                        11111111100000111111111
        //                        11111111100100111111111
        //                        11111111100100111111111
        //                        11111111111111111111111
        //                        11111111111111111111111
        //                        11111111111111111111111
        //                        11111111111111111111111
        // By default, `bitmap` has `1`s set in the positions for hat and chest
        // characters. In the following `assembly` block, we determine whether a
        // hat or chest exists and `XOR` the relevant parts to transform the
        // bitmap.
        uint256 bitmap = 0x1FFFFFFFFFFFFFFFFFFFFFFFFF07FFFE4FFFFC9FFFFFFFFFFFFFFFFFFFFFFFFF;
        uint8 hat = hyphenGuy.hat;
        uint8 chest = hyphenGuy.chest;
        assembly {
            // Equivalent to
            // `bitmap ^= (((hat != 0) << 172) | ((chest != 0) << 126))`. We
            // flip the bit corresponding to the position of the chest if there
            // exists a chest trait because we don't want to draw both a
            // background character and the chest character.
            bitmap := xor(
                bitmap,
                or(shl(172, gt(hat, 0)), shl(126, gt(chest, 0)))
            )
        }

        // Here, we initialize another bitmap to determine whether to render a
        // space character or a background character when we're not observing a
        // `hyphenGuy` character position. Since we want to render as many
        // characters in the background as equals the intensity value, we can:
        //     1. Instantiate a 253-bit long bitmap.
        //     2. Set the first `intensity` bits to `1`, and `0` otherwise.
        //     3. Shuffle the bitmap.
        // Then, by reading the bits at each index, we can determine whether to
        // render a space character (i.e. empty) or a background character. We
        // begin by instantiating an array of 253 `uint256`s, each with a single
        // `1` bit set to make use of `LibPRNG.shuffle`.
        uint256[] memory bgBitmapBits = new uint256[](253);
        for (uint256 i; i <= hyphenGuy.intensity; ) {
            bgBitmapBits[i] = 1;
            unchecked {
                ++i;
            }
        }

        // Shuffle the array if intensity mode.
        if (hyphenGuy.intensity < 252) prng.shuffle(bgBitmapBits);

        uint256 bgBitmap;
        for (uint256 i; i < 253; ) {
            // `intensity >= 252` implies `intenseBg = true`
            bgBitmap <<= 1;
            bgBitmap |= bgBitmapBits[i];
            unchecked {
                ++i;
            }
        }
        prng.state = prng.next();

        uint256 row;
        uint256 col;
        // The string corresponding to the characters of the contents of the
        // background `<text>` element.
        string memory bgStr = "";
        // The string corresponding to the characters of the contents of the
        // Hyphen Guy `<text>` element. We generate the entire first row here.
        string memory charStr = string.concat(
            "  ", // Start with 2 spaces for positioning.
            // If the hat character is `&`, we need to draw it as
            // its entity form.
            hyphenGuy.hat != 5
                ? string(abi.encodePacked(HATS[hyphenGuy.hat]))
                : "&amp;",
            hyphenGuy.hat != 0 ? "" : " ",
            "  \n"
        );
        // Iterate through the positions in reverse order. Note that the last
        // character (i.e. the one that contains ``N'' from ``CHAIN'') is not
        // drawn, and it must be accounted for after the loop.
        for (uint256 i = 252; i != 0; ) {
            assembly {
                row := div(i, 11)
                col := mod(i, 23)
            }

            // Add word characters (i.e. ``ON'' and ``CHAIN'').
            if (i == 252) bgStr = string.concat(bgStr, "O");
            else if (i == 251) bgStr = string.concat(bgStr, "N");
            else if (i < 5) {
                bgStr = string.concat(
                    bgStr,
                    string(abi.encodePacked(CHAIN_REVERSED[i]))
                );
            } else if ((bitmap >> i) & 1 == 0) {
                // Is a Hyphen Guy character.
                // Since there's a Hyphen Guy character that'll be drawn, the
                // background character in the same position must be empty.
                bgStr = string.concat(bgStr, " ");

                // Generate the Hyphen Guy by drawing rows of characters. Note
                // that we've already passed the check for whether a chest
                // character exists and applied it to the bitmap accordingly, so
                // we can safely draw the chest character here--if no chest
                // piece exists, a background character will be drawn anyway
                // because it wouldn't pass the `(bitmap >> i) & 1 == 0` check.
                if (i == 151) {
                    charStr = string.concat(
                        charStr,
                        string(abi.encodePacked(HEADS_LEFT[hyphenGuy.head])),
                        string(abi.encodePacked(EYES[hyphenGuy.eye])),
                        "-",
                        string(abi.encodePacked(EYES[hyphenGuy.eye])),
                        string(abi.encodePacked(HEADS_RIGHT[hyphenGuy.head])),
                        "\n"
                    );
                } else if (i == 128) {
                    charStr = string.concat(
                        charStr,
                        // If the arm character is `<`, we need to draw it as
                        // its entity form.
                        hyphenGuy.arm != 1
                            ? string(abi.encodePacked(ARMS_LEFT[hyphenGuy.arm]))
                            : "&lt;",
                        string(abi.encodePacked(BODIES_LEFT[hyphenGuy.body]))
                    );
                    {
                        charStr = string.concat(
                            charStr,
                            string(abi.encodePacked(CHESTS[hyphenGuy.chest])),
                            string(
                                abi.encodePacked(BODIES_RIGHT[hyphenGuy.body])
                            ),
                            // If the arm character is `>`, we need to draw it
                            // as its entity form.
                            hyphenGuy.arm != 1
                                ? string(
                                    abi.encodePacked(ARMS_RIGHT[hyphenGuy.arm])
                                )
                                : "&gt;",
                            "\n"
                        );
                    }
                } else if (i == 105) {
                    charStr = string.concat(
                        charStr,
                        "_",
                        string(abi.encodePacked(LEGS_LEFT[hyphenGuy.leg])),
                        " ",
                        string(abi.encodePacked(LEGS_RIGHT[hyphenGuy.leg])),
                        "_"
                    );
                }
            } else if ((bgBitmap >> i) & 1 != 0) {
                // We make use of the `bgBitmap` generated earlier from the
                // intensity value here. If the check above passed, it means a
                // background character must be drawn here.
                bgStr = string.concat(
                    bgStr,
                    string(
                        abi.encodePacked(
                            BACKGROUNDS[
                                // Select a random background if `chaosBg` is
                                // true.
                                hyphenGuy.chaosBg
                                    ? prng.state % 9
                                    : hyphenGuy.background
                            ]
                        )
                    )
                );
                // We need to generate a new random number for the next
                // potentially-random character.
                prng.state = prng.next();
            } else {
                // Failed all checks. Empty background character.
                bgStr = string.concat(bgStr, " ");
            }

            // Draw a newline character if we've reached the end of a row.
            if (col == 0) bgStr = string.concat(bgStr, "\n");
            unchecked {
                --i;
            }
        }

        string memory colorHexString = string.concat(
            "#",
            ((COLORS >> (hyphenGuy.color << 5)) & 0xFFFFFF).toHexStringNoPrefix(
                3
            )
        );

        return
            string.concat(
                SVG_START,
                hyphenGuy.inverted
                    ? string.concat(
                        'class="',
                        string(
                            abi.encodePacked(COLOR_CLASSES[hyphenGuy.color])
                        ),
                        '" '
                    )
                    : "",
                'd="M0 0h600v600H0z" fill="',
                hyphenGuy.inverted ? colorHexString : "#FFF",
                // `x` is `32` because we want a left padding of 32px. `y` is
                // `20` because the Martian Mono font has an overhead of 12px,
                // and we want a top padding of 32px. Thus, by setting it to
                // `32 - 12` = 20px, we align the top of the letters with 32px
                // down from the top of the SVG. `width` is `536` because we
                // want left/right padding of 32px: `600 - 32*2 = 536`. Finally,
                // `height` is `561` because we have 11 lines, and each line is
                // 51 pixels tall: `11 * 51 = 561`.
                '"/><foreignObject x="32" y="20" width="536" height="561"><pre '
                'style="color:rgba(0,0,0,0.05)" xmlns="http://www.w3.org/1999/x'
                'html">',
                bgStr,
                // Recall that ``N'' was not accounted for in the loop because
                // we didn't look at index 0, so we draw it here. `x` is `32`
                // for the same reason outlined in the previous comment. `y` is
                // `173` because the character starts 3 lines below the first
                // (`3 * 51 = 153`), and we have the same 20px overhead as
                // before, so `153 + 20 = 173`. `width` is `536` for the same
                // reason. Finally, `height` is `204` because the character is 4
                // lines tall, and each line is 51 pixels tall: `4 * 51 = 204`.
                'N</pre></foreignObject><foreignObject x="32" y="173" width="53'
                '6" height="204"><pre',
                hyphenGuy.inverted
                    ? ""
                    : string.concat(
                        ' class="',
                        string(
                            abi.encodePacked(COLOR_CLASSES[hyphenGuy.color])
                        ),
                        '"'
                    ),
                ' style="color:',
                hyphenGuy.inverted ? "#FFF" : colorHexString,
                '" xmlns="http://www.w3.org/1999/xhtml">',
                charStr,
                SVG_END
            );
    }
}

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

import {LibString} from "solady/utils/LibString.sol";
import {AdoptAHyphenArt} from "./AdoptAHyphenArt.sol";

/// @title adopt-a-hyphen metadata
/// @notice A library for generating metadata for {AdoptAHyphen}.
/// @dev For this library to be correct, all `_seed` values must be consistent
/// with every function in both {AdoptAHyphenArt} and {AdoptAHyphenMetadata}.
library AdoptAHyphenMetadata {
    using LibString for string;
    using LibString for uint256;

    /// @notice Number of bits used to generate the art. We take note of this
    /// because we don't want to use the same bits to generate the metadata.
    uint256 constant BITS_USED = 47;

    /// @notice Joined list of adjectives to use when generating the name with
    /// `_` as the delimiter.
    /// @dev To read from this constant, use
    /// `LibString.split(string(ADJECTIVES), "_")`.
    bytes constant ADJECTIVES =
        "All-Important_Angel-Faced_Awe-Inspiring_Battle-Scarred_Big-Boned_Bird-"
        "Like_Black-and-White_Breath-Taking_Bright-Eyed_Broad-Shouldered_Bull-H"
        "eaded_Butter-Soft_Cat-Eyed_Cool-Headed_Cross-Eyed_Death-Defying_Devil-"
        "May-Care_Dew-Fresh_Dim-Witted_Down-to-Earth_Eagle-Nosed_Easy-Going_Eve"
        "r-Changing_Faint-Hearted_Feather-Brained_Fish-Eyed_Fly-by-Night_Free-T"
        "hinking_Fun-Loving_Half-Baked_Hawk-Eyed_Heart-Breaking_High-Spirited_H"
        "oney-Dipped_Honey-Tongued_Ice-Cold_Ill-Gotten_Iron-Grey_Iron-Willed_Ke"
        "en-Eyed_Kind-Hearted_Left-Handed_Lion-Hearted_Off-the-Grid_Open-Faced_"
        "Pale-Faced_Razor-Sharp_Red-Faced_Rosy-Cheeked_Ruby-Red_Self-Satisfied_"
        "Sharp-Nosed_Short-Sighted_Silky-Haired_Silver-Tongued_Sky-Blue_Slow-Fo"
        "oted_Smooth-as-Silk_Smooth-Talking_Snake-Like_Snow-Cold_Snow-White_Sof"
        "t-Voiced_Sour-Faced_Steel-Blue_Stiff-Necked_Straight-Laced_Strong-Mind"
        "ed_Sugar-Sweet_Thick-Headed_Tight-Fisted_Tongue-in-Cheek_Tough-Minded_"
        "Trigger-Happy_Velvet-Voiced_Water-Washed_White-Faced_Wide-Ranging_Wild"
        "-Haired_Wishy-Washy_Work-Weary_Yellow-Bellied_Camera-Shy_Cold-as-Ice_E"
        "mpty-Handed_Fair-Weather_Fire-Breathing_Jaw-Dropping_Mind-Boggling_No-"
        "Nonsense_Rough-and-ready_Slap-Happy_Smooth-Faced_Snail-Paced_Soul-Sear"
        "ching_Star-Studded_Tongue-Tied_Too-Good-to-be-True_Turtle-Necked_Diamo"
        "nd-Handed";

    /// @notice Joined list of first names to use when generating the name with
    /// `_` as the delimiter.
    /// @dev To read from this constant, use
    /// `LibString.split(string(FIRST_NAMES), "_")`.
    bytes constant FIRST_NAMES =
        "Alexis_Ali_Alicia_Andres_Asha_Barb_Betty_Bruce_Charles_Chris_Coco_Dan_"
        "David_Dennis_Elijah_Eugene_James_Jayden_Jenny_Jess_Joe_John_Jose_Karen"
        "_Linda_Lisa_Liz_Marco_Mark_Mary_Matt_Mert_Mike_Mirra_Nancy_Noor_Novak_"
        "Patty_Peggy_Ravi_Richard_Robert_Sandra_Sarah_Sue_Tayne_Tom_Tony_Will_Y"
        "ana";

    /// @notice Joined list of hue names to use when generating the name with
    /// `_` as the delimiter.
    /// @dev To read from this constant, use
    /// `LibString.split(string(HUES), "_")`.
    bytes constant HUES = "red_blue_orange_teal_pink_green_purple_gray";

    /// @notice Joined list of hobbies to use when generating the name with `_`
    /// as the delimiter.
    /// @dev To read from this constant, use
    /// `LibString.split(string(HOBBIES), "_")`.
    bytes constant HOBBIES =
        "blit-mapp_terra-form_shield-build_loot-bagg_OKPC-draw_mooncat-rescu_au"
        "to-glyph_animal-color_ava-starr_party-card_chain-runn_forgotten-run_bi"
        "bo-glint";

    /// @notice Generates a Hyphen Guy name.
    /// @param _seed Seed to select traits for the Hyphen Guy.
    /// @return Hyphen Guy's name.
    function generateName(uint256 _seed) internal pure returns (string memory) {
        string[] memory adjectives = string(ADJECTIVES).split("_");
        string[] memory firstNames = string(FIRST_NAMES).split("_");

        _seed >>= BITS_USED;

        return
            string.concat(
                firstNames[(_seed >> 7) % 50], // Adjectives used 7 bits
                " ",
                adjectives[_seed % 100]
            );
    }

    /// @notice Generates a Hyphen Guy's attributes.
    /// @param _seed Seed to select traits for the Hyphen Guy.
    /// @return Hyphen Guy's attributes.
    function generateAttributes(
        uint256 _seed
    ) internal pure returns (string memory) {
        string[] memory hues = string(HUES).split("_");
        string[] memory hobbies = string(HOBBIES).split("_");

        // We directly use the value of `_seed` because we don't need further
        // randomness.
        // The bits used to determine the color value are bits [24, 27]
        // (0-indexed). See {AdoptAHyphenArt.render} for more information.
        uint256 background = (_seed >> 24) % 9;

        // The bits used to determine whether the background is in ``intensity
        // mode'' or not are bits [30, 31] (0-indexed). See
        // {AdoptAHyphenArt.render} for more information.
        bool intensityMode = ((_seed >> 30) & 3) == 0;

        // The bits used to determine the color value are bits [43, 45]
        // (0-indexed). See {AdoptAHyphenArt.render} for more information.
        uint256 color = (_seed >> 43) & 7;

        // The art renderer uses the last `BITS_USED` bits to generate its
        // traits, and `generateName` uses 12 bits to generate the name, so we
        // shift those portions off.
        _seed >>= BITS_USED;
        _seed >>= 12;
        uint256 rizz = _seed % 101; // [0, 100] (7 bits)
        _seed >>= 7;
        uint256 hobby = _seed % 13; // 13 hobbies (4 bits)
        _seed >>= 4;

        return
            string.concat(
                '[{"trait_type":"hue","value":"',
                hues[color],
                '"},',
                '{"trait_type":"vibe","value":"',
                background == 6
                    ? "\\\\"
                    : string(
                        abi.encodePacked(
                            AdoptAHyphenArt.BACKGROUNDS[background]
                        )
                    ),
                '"},{"trait_type":"demeanor","value":"',
                intensityMode ? "ex" : "in",
                'troverted"},{"trait_type":"hobby","value":"',
                hobbies[hobby],
                'ing"},{"trait_type":"rizz","value":',
                rizz.toString(),
                "}]"
            );
    }
}

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

/// @title Base64
/// @author Brecht Devos - <[email protected]>
/// @notice Provides a function for encoding some bytes in base64
library Base64 {
    string internal constant TABLE =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345678"
        "9+/";

    function encode(bytes memory data) internal pure returns (string memory) {
        if (data.length == 0) return "";
        string memory table = TABLE;
        uint256 encodedLength = ((data.length + 2) / 3) << 2;
        string memory result = new string(encodedLength + 0x20);

        assembly {
            mstore(result, encodedLength)
            let tablePtr := add(table, 1)
            let dataPtr := data
            let endPtr := add(dataPtr, mload(data))
            let resultPtr := add(result, 0x20)

            for {

            } lt(dataPtr, endPtr) {

            } {
                dataPtr := add(dataPtr, 3)
                let input := mload(dataPtr)
                mstore(
                    resultPtr,
                    shl(0xF8, mload(add(tablePtr, and(shr(0x12, input), 0x3F))))
                )
                resultPtr := add(resultPtr, 1)
                mstore(
                    resultPtr,
                    shl(0xF8, mload(add(tablePtr, and(shr(0xC, input), 0x3F))))
                )
                resultPtr := add(resultPtr, 1)
                mstore(
                    resultPtr,
                    shl(0xF8, mload(add(tablePtr, and(shr(6, input), 0x3F))))
                )
                resultPtr := add(resultPtr, 1)
                mstore(
                    resultPtr,
                    shl(0xF8, mload(add(tablePtr, and(input, 0x3F))))
                )
                resultPtr := add(resultPtr, 1)
            }
            switch mod(mload(data), 3)
            case 1 {
                mstore(sub(resultPtr, 2), shl(0xF0, 0x3D3D))
            }
            case 2 {
                mstore(sub(resultPtr, 1), shl(0xF8, 0x3D))
            }
        }

        return result;
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /// @dev Returns the base 10 decimal representation of `value`.
    function toString(uint256 value) internal pure returns (string memory str) {
        /// @solidity memory-safe-assembly
        assembly {
            // The maximum value of a uint256 contains 78 digits (1 byte per digit), but
            // we allocate 0xa0 bytes to keep the free memory pointer 32-byte word aligned.
            // We will need 1 word for the trailing zeros padding, 1 word for the length,
            // and 3 words for a maximum of 78 digits.
            str := add(mload(0x40), 0x80)
            // Update the free memory pointer to allocate.
            mstore(0x40, add(str, 0x20))
            // Zeroize the slot after the string.
            mstore(str, 0)

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

            let w := not(0) // Tsk.
            // We write the string from rightmost digit to leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            for { let temp := value } 1 {} {
                str := add(str, w) // `sub(str, 1)`.
                // Write the character to the pointer.
                // The ASCII index of the '0' character is 48.
                mstore8(str, add(48, mod(temp, 10)))
                // Keep dividing `temp` until zero.
                temp := div(temp, 10)
                if iszero(temp) { break }
            }

            let length := sub(end, str)
            // Move the pointer 32 bytes leftwards to make room for the length.
            str := sub(str, 0x20)
            // Store the length.
            mstore(str, length)
        }
    }

    /// @dev Returns the base 10 decimal representation of `value`.
    function toString(int256 value) internal pure returns (string memory str) {
        if (value >= 0) {
            return toString(uint256(value));
        }
        unchecked {
            str = toString(uint256(-value));
        }
        /// @solidity memory-safe-assembly
        assembly {
            // We still have some spare memory space on the left,
            // as we have allocated 3 words (96 bytes) for up to 78 digits.
            let length := mload(str) // Load the string length.
            mstore(str, 0x2d) // Store the '-' character.
            str := sub(str, 1) // Move back the string pointer by a byte.
            mstore(str, add(length, 1)) // Update the string length.
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            value := shl(96, value)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{
  "remappings": [
    "ds-test/=lib/forge-std/lib/ds-test/src/",
    "forge-std/=lib/forge-std/src/",
    "solady/=lib/solady/src/",
    "solmate/=lib/solmate/src/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 7777777
  },
  "metadata": {
    "bytecodeHash": "none"
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "london",
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_hyphenNft","type":"address"},{"internalType":"address","name":"_owner","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"TokenUnminted","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hyphenNft","outputs":[{"internalType":"contract IERC721","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"owner","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

00000000000000000000000073d24948fd946ae7f20eed63d7c0680edfaf36f100000000000000000000000008995fac0a721170e5f2179a1402c786f86535a3

-----Decoded View---------------
Arg [0] : _hyphenNft (address): 0x73d24948fD946AE7F20EED63D7C0680eDfaF36f1
Arg [1] : _owner (address): 0x08995fAC0a721170E5f2179A1402C786f86535a3

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 00000000000000000000000073d24948fd946ae7f20eed63d7c0680edfaf36f1
Arg [1] : 00000000000000000000000008995fac0a721170e5f2179a1402c786f86535a3