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: UNLICENSE
pragma solidity 0.8.20;

import {Program, Params} from "./Program.sol";
import {ERC721} from "../lib/solmate/src/tokens/ERC721.sol";
import {Antigraviton} from "./Antigraviton.sol";
import {Research} from "./Research.sol";
import {LibString} from "../lib/solady/src/utils/LibString.sol";
import {ERC2981} from "lib/openzeppelin-contracts/contracts/token/common/ERC2981.sol";

contract AngelMatter is ERC721("Angel Matter", "AM"), ERC2981 {
    uint256 constant SUPPLY = 3333;
    uint256 constant PRICE = 0.01618 ether;
    uint256 constant COLLISION = 3333333 ether;

    Antigraviton public anti;
    Research public research;
    Program public program;

    address public owner;
    uint256 public startTime;

    uint256 public currentId;

    mapping(uint256 => uint256) public prestige;
    mapping(uint256 => uint256) public seed;
    mapping(uint256 => uint8) public level;
    mapping(uint256 => uint8) public spin;
    mapping(uint256 => uint8) public redacted;
    mapping(uint256 => string) public prism;

    mapping(uint256 => uint256) public claimed;

    modifier onlyHolder(uint256 id) {
        require(msg.sender == ownerOf(id));
        _;
    }

    constructor(address _owner, uint256 _startTime) {
        anti = new Antigraviton();
        research = new Research();
        program = new Program();

        owner = _owner;
        startTime = _startTime;

        _setDefaultRoyalty(_owner, 333);
    }

    function mint(uint256 _amount) external payable {
        require(startTime <= block.timestamp || msg.sender == owner);
        require(msg.value == _amount * PRICE || msg.sender == owner);
        require(currentId + _amount <= SUPPLY);
        uint256 i;
        for (i; i < _amount; ) {
            unchecked {
                uint256 id = ++currentId;
                seed[id] = _prandom(id);
                _mint(msg.sender, id);
                ++i;
                if (id % 2 == 0) {
                    spin[id] = 1;
                }
                prism[id] = "0";
            }
        }
    }

    function claimAnti(uint256 id) public onlyHolder(id) {
        uint256 vb = virtualAnti(id);
        claimed[id] += vb;
        anti.mint(msg.sender, vb);
    }

    function virtualAnti(uint256 id) public view returns (uint256) {
        return ((block.timestamp - startTime) * 1 ether) - claimed[id];
    }

    function collide(uint256 id, string memory signal) external onlyHolder(id) {
        require((anti.balanceOf(msg.sender) + virtualAnti(id)) >= COLLISION);

        claimAnti(id);
        anti.burn(msg.sender, COLLISION);
        research.mint(msg.sender, ++prestige[id]);
        if (redacted[id] == 1) {
            redacted[id] = 0;
            research.mint(msg.sender, 0);
        }

        seed[id] = uint256(keccak256(abi.encodePacked(signal, id)));
        level[id] = 0;
        prism[id] = "0";
    }

    function observe(
        uint256 id,
        uint256[][] memory arr
    ) external onlyHolder(id) {
        require(arr.length == 5);
        string memory str = "[";
        for (uint256 i; i < 5; ++i) {
            require(arr[i].length == 5);
            str = string.concat(str, "[");
            for (uint256 j; j < 5; ++j) {
                require(arr[i][j] < 6);
                str = string.concat(str, LibString.toString(arr[i][j]));
                if (j < 4) {
                    str = string.concat(str, ",");
                } else {
                    str = string.concat(str, "]");
                }
            }
            if (i < 4) {
                str = string.concat(str, ",");
            } else {
                str = string.concat(str, "]");
            }
        }
        prism[id] = str;
    }

    function xe(uint256 id) external onlyHolder(id) {
        require(redacted[id] == 0);
        require(level[id] == 100);
        require(
            keccak256(abi.encodePacked(prism[id])) ==
                0x18dd307dad56bbc1962747ba3045a38d4d58443f58f1cc44ef53fb0c22e75bdf
        );
        require(block.timestamp % 5256000 > 5169600);
        redacted[id] = 1;
    }

    function invert(uint256 id) external onlyHolder(id) {
        if (spin[id] == 0) {
            spin[id] = 1;
        } else {
            spin[id] = 0;
        }
    }

    function tokenURI(uint256 id) public view override returns (string memory) {
        Params memory params = Params(
            id,
            seed[id],
            prestige[id],
            prism[id],
            ownerOf(id),
            spin[id],
            level[id],
            redacted[id]
        );

        return program.uri(params);
    }

    function transferFrom(
        address from,
        address to,
        uint256 id
    ) public override {
        if (level[id] < 100) {
            ++level[id];
        }
        super.transferFrom(from, to, id);
    }

    function safeTransferFrom(
        address from,
        address to,
        uint256 id
    ) public override {
        if (level[id] < 100) {
            ++level[id];
        }
        super.safeTransferFrom(from, to, id);
    }

    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        bytes calldata data
    ) public override {
        if (level[id] < 100) {
            ++level[id];
        }
        super.safeTransferFrom(from, to, id, data);
    }

    function _prandom(uint256 id) internal view returns (uint256) {
        return
            uint256(
                keccak256(abi.encodePacked(blockhash(block.number - 1), id))
            );
    }

    function withdraw() external {
        require(msg.sender == owner);
        (bool succ, ) = owner.call{value: address(this).balance}("");
        require(succ);
    }

    function supportsInterface(
        bytes4 interfaceId
    ) public view override(ERC721, ERC2981) returns (bool) {
        return
            interfaceId == 0x01ffc9a7 ||
            interfaceId == 0x80ac58cd ||
            interfaceId == 0x5b5e139f ||
            interfaceId == 0x2a55205a;
    }
}

// SPDX-License-Identifier: UNLICENSE
pragma solidity 0.8.20;

import {Particle} from "./Particle.sol";
import {Base64} from "../lib/solady/src/utils/Base64.sol";
import {LibString} from "../lib/solady/src/utils/LibString.sol";
import {IFileStore} from "../lib/ethfs/packages/contracts/src/IFileStore.sol";

struct Params {
    uint256 id;
    uint256 seed;
    uint256 pres;
    string ar;
    address wal;
    uint8 inv;
    uint8 lvl;
    uint8 asc;
}

contract Program {
    using LibString for uint256;
    using LibString for uint160;
    using LibString for uint8;

    IFileStore fileStore;
    string desc =
        '"description":"In a far away parallel universe an advanced civilization built a computer around a star and escaped into a simulated reality. After some immeasurable amount of time these facts were forgotten and after another immeasurable amount of time that star began to die. Even so, life Inside this simulation progressed, and on one planet some of that life progressed enough to form a government. You are the new member of a mysterious project under a secret agency of this government researching the elementary particles that make up your universe.",';

    constructor() {
        fileStore = IFileStore(0x9746fD0A77829E12F8A9DBe70D7a322412325B91);
    }

    function _parameters(
        Params memory _params
    ) internal view returns (string memory) {
        return
            string.concat(
                '<script src="data:text/javascript;base64,',
                Base64.encode(
                    abi.encodePacked(
                        string.concat(
                            "let seed = ",
                            (_params.seed % 9007199254740991).toString(),
                            "; let tim = ",
                            block.timestamp.toString(),
                            "; let ar = ",
                            _params.ar,
                            "; let wal = ",
                            (uint160(_params.wal) % 9007199254740991)
                                .toString(),
                            "; let inv = ",
                            _params.inv.toString(),
                            "; let lvl = ",
                            _params.lvl.toString(),
                            "; let asc = ",
                            _params.asc.toString(),
                            ";"
                        )
                    )
                )
            );
    }

    function _scripts(
        Params memory _params
    ) internal view returns (string memory) {
        return
            string.concat(
                '<script type="text/javascript+gzip" src="data:text/javascript;base64,',
                fileStore.getFile("p5-v1.5.0.min.js.gz").read(),
                '"></script>',
                '<script src="data:text/javascript;base64,',
                fileStore.getFile("gunzipScripts-0.0.1.js").read(),
                '"></script>',
                _parameters(_params),
                '"></script><script src="data:text/javascript;base64,',
                fileStore.getFile(":)").read(),
                '"></script>'
            );
    }

    function _page(
        Params memory _params
    ) internal view returns (string memory) {
        return
            string.concat(
                '"animation_url":"data:text/html;base64,',
                Base64.encode(
                    abi.encodePacked(
                        string.concat(
                            '<!DOCTYPE html><html style="height: 100%;"><head>',
                            _scripts(_params),
                            '</head><body style="margin: 0;display: flex;justify-content: center;align-items: center;height: 100%;"></body></html>'
                        )
                    )
                ),
                '",'
            );
    }

    function _attributes(
        Params memory _params
    ) internal pure returns (string memory) {
        string memory atr = string.concat(
            '"attributes": [{"trait_type": "Decay", "value": ',
            _params.lvl.toString(),
            "}, ",
            '{"display_type": "number","trait_type": "Prestige", "value": ',
            _params.pres.toString(),
            "}, "
        );

        atr = _params.inv > 0
            ? string.concat(atr, '{"trait_type": "Spin", "value": "Up"},')
            : string.concat(atr, '{"trait_type": "Spin", "value": "Down"},');

        atr = bytes(_params.ar).length > 1
            ? string.concat(atr, '{"trait_type": "Prism", "value": "Advanced"}')
            : string.concat(
                atr,
                '{"trait_type": "Prism", "value": "Original"}'
            );

        if (_params.asc > 0) {
            atr = string.concat(
                atr,
                ', {"trait_type": "[REDACTED]", "value": "[REDACTED]"}'
            );
        }

        if (_params.id < 1000 && _params.id % 111 == 0) {
            atr = string.concat(
                atr,
                ', {"trait_type": "Angel", "value": "',
                _params.id.toString(),
                '"}'
            );
        }

        if (_params.id % 1111 == 0) {
            atr = string.concat(
                atr,
                ', {"trait_type": "Hyper Angel", "value": "',
                _params.id.toString(),
                '"}'
            );
        }

        return string.concat(atr, "]}");
    }

    function uri(Params memory _params) external view returns (string memory) {
        return
            string.concat(
                "data:application/json;base64,",
                Base64.encode(
                    abi.encodePacked(
                        string.concat(
                            '{"name":">>> ',
                            _params.id.toString(),
                            ' <<<",',
                            desc,
                            '"image":"',
                            Particle._image(bytes32(_params.seed)),
                            '",',
                            _page(_params),
                            _attributes(_params)
                        )
                    )
                )
            );
    }
}

// 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: UNLICENSE
pragma solidity 0.8.20;

import {ERC20} from "../lib/solmate/src/tokens/ERC20.sol";

contract Antigraviton is ERC20 {
    address immutable angel;

    constructor() ERC20("Antigraviton", "φ", 18) {
        angel = msg.sender;
    }

    function mint(address to, uint256 amount) external {
        require(msg.sender == angel);
        _mint(to, amount);
    }

    function burn(address from, uint256 amount) external {
        require(msg.sender == angel);
        _burn(from, amount);
    }
}

// SPDX-License-Identifier: UNLICENSE
pragma solidity 0.8.20;

import {ERC1155} from "../lib/solmate/src/tokens/ERC1155.sol";
import {Collision} from "./Collision.sol";

contract Research is ERC1155 {
    address immutable angel;

    Collision public collision;

    string public name = "Angel Matter Research";
    string public symbol = "AMR";

    constructor() {
        angel = msg.sender;
        collision = new Collision();
    }

    function mint(address to, uint256 id) external {
        require(msg.sender == angel);
        _mint(to, id, 1, "");
    }

    function uri(uint256 id) public view override returns (string memory) {
        return collision.uri(id);
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            value := shl(96, value)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/common/ERC2981.sol)

pragma solidity ^0.8.19;

import "../../interfaces/IERC2981.sol";
import "../../utils/introspection/ERC165.sol";

/**
 * @dev Implementation of the NFT Royalty Standard, a standardized way to retrieve royalty payment information.
 *
 * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for
 * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first.
 *
 * Royalty is specified as a fraction of sale price. {_feeDenominator} is overridable but defaults to 10000, meaning the
 * fee is specified in basis points by default.
 *
 * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See
 * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to
 * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported.
 *
 * _Available since v4.5._
 */
abstract contract ERC2981 is IERC2981, ERC165 {
    struct RoyaltyInfo {
        address receiver;
        uint96 royaltyFraction;
    }

    RoyaltyInfo private _defaultRoyaltyInfo;
    mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo;

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC165) returns (bool) {
        return interfaceId == type(IERC2981).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @inheritdoc IERC2981
     */
    function royaltyInfo(uint256 tokenId, uint256 salePrice) public view virtual override returns (address, uint256) {
        RoyaltyInfo memory royalty = _tokenRoyaltyInfo[tokenId];

        if (royalty.receiver == address(0)) {
            royalty = _defaultRoyaltyInfo;
        }

        uint256 royaltyAmount = (salePrice * royalty.royaltyFraction) / _feeDenominator();

        return (royalty.receiver, royaltyAmount);
    }

    /**
     * @dev The denominator with which to interpret the fee set in {_setTokenRoyalty} and {_setDefaultRoyalty} as a
     * fraction of the sale price. Defaults to 10000 so fees are expressed in basis points, but may be customized by an
     * override.
     */
    function _feeDenominator() internal pure virtual returns (uint96) {
        return 10000;
    }

    /**
     * @dev Sets the royalty information that all ids in this contract will default to.
     *
     * Requirements:
     *
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual {
        require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
        require(receiver != address(0), "ERC2981: invalid receiver");

        _defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Removes default royalty information.
     */
    function _deleteDefaultRoyalty() internal virtual {
        delete _defaultRoyaltyInfo;
    }

    /**
     * @dev Sets the royalty information for a specific token id, overriding the global default.
     *
     * Requirements:
     *
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setTokenRoyalty(uint256 tokenId, address receiver, uint96 feeNumerator) internal virtual {
        require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
        require(receiver != address(0), "ERC2981: Invalid parameters");

        _tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Resets royalty information for the token id back to the global default.
     */
    function _resetTokenRoyalty(uint256 tokenId) internal virtual {
        delete _tokenRoyaltyInfo[tokenId];
    }
}

// SPDX-License-Identifier: UNLICENSE
pragma solidity 0.8.20;

import {Base64} from "../lib/solady/src/utils/Base64.sol";
import {LibString} from "../lib/solady/src/utils/LibString.sol";

library Particle {
    using LibString for uint8;
    using LibString for uint160;
    using LibString for uint256;

    function _upper() internal pure returns (string memory) {
        return
            string(
                abi.encodePacked(
                    '<svg height="250" width="250" xmlns="http://www.w3.org/2000/svg">',
                    "<defs>",
                    '<radialGradient id="myGradient">'
                )
            );
    }

    function _orbital(
        bytes32 seed,
        uint8 num
    ) internal pure returns (string memory) {
        string memory first = string(
            abi.encodePacked(
                '<stop offset="',
                (5 + num * 20).toString(),
                '%" stop-color="rgb(',
                uint8(seed[0 + (num * 6)]).toString(),
                ",",
                uint8(seed[1 + (num * 6)]).toString(),
                ",",
                uint8(seed[2 + (num * 6)]).toString(),
                ')" />'
            )
        );
        string memory second = string(
            abi.encodePacked(
                '<stop offset="',
                (15 + num * 20).toString(),
                '%" stop-color="rgb(',
                uint8(seed[3 + (num * 6)]).toString(),
                ",",
                uint8(seed[4 + (num * 6)]).toString(),
                ",",
                uint8(seed[5 + (num * 6)]).toString(),
                ')" />'
            )
        );
        return string(abi.encodePacked(first, second));
    }

    function _lower() internal pure returns (string memory) {
        return
            string(
                abi.encodePacked(
                    "</radialGradient>",
                    "</defs>",
                    '<rect height="250" width="250" fill="#000"></rect>'
                )
            );
    }

    function _elements(bytes32 seed) internal pure returns (string memory) {
        string[16] memory elements = [
            "&#10696;",
            "&#9737;",
            "&#8853;",
            "&#128842;",
            "&#10023;",
            "&#9672;",
            "&#10070;",
            "&#10803;",
            "&#10040;",
            "&#10057;",
            "&#128779;",
            "&#9883;",
            "&#8258;",
            "&#9738;",
            "&#9854;",
            "&#8578;"
        ];

        string memory a = elements[uint8(seed[31]) & 15];
        string memory b = elements[(uint8(seed[31]) & 240) / 16];
        string memory c = elements[uint8(seed[30]) & 15];
        string memory d = elements[(uint8(seed[30]) & 240) / 16];

        return
            string(
                abi.encodePacked(
                    '<text fill="#ffffff" font-size="30" font-family="Verdana" x="32" y="42" text-anchor="middle">',
                    a,
                    "</text>",
                    '<text fill="#ffffff" font-size="30" font-family="Verdana" x="218" y="42" text-anchor="middle">',
                    b,
                    "</text>",
                    '<text fill="#ffffff" font-size="30" font-family="Verdana" x="32" y="228" text-anchor="middle">',
                    c,
                    "</text>",
                    '<text fill="#ffffff" font-size="30" font-family="Verdana" x="218" y="228" text-anchor="middle">',
                    d,
                    "</text>"
                )
            );
    }

    function _power() internal pure returns (string memory) {
        return
            string(
                abi.encodePacked(
                    '<circle cx="125" cy="125" r="100" fill="url(\'#myGradient\')" />',
                    "</svg>"
                )
            );
    }

    function _particle(bytes32 seed) internal pure returns (string memory) {
        return
            string(
                abi.encodePacked(
                    _upper(),
                    _orbital(seed, 0),
                    _orbital(seed, 1),
                    _orbital(seed, 2),
                    _orbital(seed, 3),
                    _orbital(seed, 4),
                    _lower(),
                    _elements(seed),
                    _power()
                )
            );
    }

    function _image(bytes32 seed) internal pure returns (string memory) {
        string memory image = _particle(seed);
        return
            string(
                abi.encodePacked(
                    "data:image/svg+xml;base64,",
                    Base64.encode(bytes(image))
                )
            );
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.13;

import {File} from "./File.sol";
import {IContentStore} from "./IContentStore.sol";

interface IFileStore {
    event FileCreated(
        string indexed indexedFilename,
        bytes32 indexed checksum,
        string filename,
        uint256 size,
        bytes metadata
    );
    event FileDeleted(
        string indexed indexedFilename,
        bytes32 indexed checksum,
        string filename
    );

    error FileNotFound(string filename);
    error FilenameExists(string filename);
    error EmptyFile();

    function contentStore() external view returns (IContentStore);

    function files(string memory filename)
        external
        view
        returns (bytes32 checksum);

    function fileExists(string memory filename) external view returns (bool);

    function getChecksum(string memory filename)
        external
        view
        returns (bytes32 checksum);

    function getFile(string memory filename)
        external
        view
        returns (File memory file);

    function createFile(string memory filename, bytes32[] memory checksums)
        external
        returns (File memory file);

    function createFile(
        string memory filename,
        bytes32[] memory checksums,
        bytes memory extraData
    ) external returns (File memory file);

    function deleteFile(string memory filename) external;
}

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

/// @notice Modern and gas efficient ERC20 + EIP-2612 implementation.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol)
/// @author Modified from Uniswap (https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol)
/// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it.
abstract contract ERC20 {
    /*//////////////////////////////////////////////////////////////
                                 EVENTS
    //////////////////////////////////////////////////////////////*/

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

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

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

    string public name;

    string public symbol;

    uint8 public immutable decimals;

    /*//////////////////////////////////////////////////////////////
                              ERC20 STORAGE
    //////////////////////////////////////////////////////////////*/

    uint256 public totalSupply;

    mapping(address => uint256) public balanceOf;

    mapping(address => mapping(address => uint256)) public allowance;

    /*//////////////////////////////////////////////////////////////
                            EIP-2612 STORAGE
    //////////////////////////////////////////////////////////////*/

    uint256 internal immutable INITIAL_CHAIN_ID;

    bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;

    mapping(address => uint256) public nonces;

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

    constructor(
        string memory _name,
        string memory _symbol,
        uint8 _decimals
    ) {
        name = _name;
        symbol = _symbol;
        decimals = _decimals;

        INITIAL_CHAIN_ID = block.chainid;
        INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
    }

    /*//////////////////////////////////////////////////////////////
                               ERC20 LOGIC
    //////////////////////////////////////////////////////////////*/

    function approve(address spender, uint256 amount) public virtual returns (bool) {
        allowance[msg.sender][spender] = amount;

        emit Approval(msg.sender, spender, amount);

        return true;
    }

    function transfer(address to, uint256 amount) public virtual returns (bool) {
        balanceOf[msg.sender] -= amount;

        // Cannot overflow because the sum of all user
        // balances can't exceed the max uint256 value.
        unchecked {
            balanceOf[to] += amount;
        }

        emit Transfer(msg.sender, to, amount);

        return true;
    }

    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual returns (bool) {
        uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals.

        if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount;

        balanceOf[from] -= amount;

        // Cannot overflow because the sum of all user
        // balances can't exceed the max uint256 value.
        unchecked {
            balanceOf[to] += amount;
        }

        emit Transfer(from, to, amount);

        return true;
    }

    /*//////////////////////////////////////////////////////////////
                             EIP-2612 LOGIC
    //////////////////////////////////////////////////////////////*/

    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual {
        require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED");

        // Unchecked because the only math done is incrementing
        // the owner's nonce which cannot realistically overflow.
        unchecked {
            address recoveredAddress = ecrecover(
                keccak256(
                    abi.encodePacked(
                        "\x19\x01",
                        DOMAIN_SEPARATOR(),
                        keccak256(
                            abi.encode(
                                keccak256(
                                    "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
                                ),
                                owner,
                                spender,
                                value,
                                nonces[owner]++,
                                deadline
                            )
                        )
                    )
                ),
                v,
                r,
                s
            );

            require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_SIGNER");

            allowance[recoveredAddress][spender] = value;
        }

        emit Approval(owner, spender, value);
    }

    function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
        return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();
    }

    function computeDomainSeparator() internal view virtual returns (bytes32) {
        return
            keccak256(
                abi.encode(
                    keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
                    keccak256(bytes(name)),
                    keccak256("1"),
                    block.chainid,
                    address(this)
                )
            );
    }

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

    function _mint(address to, uint256 amount) internal virtual {
        totalSupply += amount;

        // Cannot overflow because the sum of all user
        // balances can't exceed the max uint256 value.
        unchecked {
            balanceOf[to] += amount;
        }

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

    function _burn(address from, uint256 amount) internal virtual {
        balanceOf[from] -= amount;

        // Cannot underflow because a user's balance
        // will never be larger than the total supply.
        unchecked {
            totalSupply -= amount;
        }

        emit Transfer(from, address(0), amount);
    }
}

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

/// @notice Minimalist and gas efficient standard ERC1155 implementation.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC1155.sol)
abstract contract ERC1155 {
    /*//////////////////////////////////////////////////////////////
                                 EVENTS
    //////////////////////////////////////////////////////////////*/

    event TransferSingle(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256 id,
        uint256 amount
    );

    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] ids,
        uint256[] amounts
    );

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

    event URI(string value, uint256 indexed id);

    /*//////////////////////////////////////////////////////////////
                             ERC1155 STORAGE
    //////////////////////////////////////////////////////////////*/

    mapping(address => mapping(uint256 => uint256)) public balanceOf;

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

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

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

    /*//////////////////////////////////////////////////////////////
                              ERC1155 LOGIC
    //////////////////////////////////////////////////////////////*/

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

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

    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes calldata data
    ) public virtual {
        require(msg.sender == from || isApprovedForAll[from][msg.sender], "NOT_AUTHORIZED");

        balanceOf[from][id] -= amount;
        balanceOf[to][id] += amount;

        emit TransferSingle(msg.sender, from, to, id, amount);

        require(
            to.code.length == 0
                ? to != address(0)
                : ERC1155TokenReceiver(to).onERC1155Received(msg.sender, from, id, amount, data) ==
                    ERC1155TokenReceiver.onERC1155Received.selector,
            "UNSAFE_RECIPIENT"
        );
    }

    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) public virtual {
        require(ids.length == amounts.length, "LENGTH_MISMATCH");

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

        // Storing these outside the loop saves ~15 gas per iteration.
        uint256 id;
        uint256 amount;

        for (uint256 i = 0; i < ids.length; ) {
            id = ids[i];
            amount = amounts[i];

            balanceOf[from][id] -= amount;
            balanceOf[to][id] += amount;

            // An array can't have a total length
            // larger than the max uint256 value.
            unchecked {
                ++i;
            }
        }

        emit TransferBatch(msg.sender, from, to, ids, amounts);

        require(
            to.code.length == 0
                ? to != address(0)
                : ERC1155TokenReceiver(to).onERC1155BatchReceived(msg.sender, from, ids, amounts, data) ==
                    ERC1155TokenReceiver.onERC1155BatchReceived.selector,
            "UNSAFE_RECIPIENT"
        );
    }

    function balanceOfBatch(address[] calldata owners, uint256[] calldata ids)
        public
        view
        virtual
        returns (uint256[] memory balances)
    {
        require(owners.length == ids.length, "LENGTH_MISMATCH");

        balances = new uint256[](owners.length);

        // Unchecked because the only math done is incrementing
        // the array index counter which cannot possibly overflow.
        unchecked {
            for (uint256 i = 0; i < owners.length; ++i) {
                balances[i] = balanceOf[owners[i]][ids[i]];
            }
        }
    }

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

    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return
            interfaceId == 0x01ffc9a7 || // ERC165 Interface ID for ERC165
            interfaceId == 0xd9b67a26 || // ERC165 Interface ID for ERC1155
            interfaceId == 0x0e89341c; // ERC165 Interface ID for ERC1155MetadataURI
    }

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

    function _mint(
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        balanceOf[to][id] += amount;

        emit TransferSingle(msg.sender, address(0), to, id, amount);

        require(
            to.code.length == 0
                ? to != address(0)
                : ERC1155TokenReceiver(to).onERC1155Received(msg.sender, address(0), id, amount, data) ==
                    ERC1155TokenReceiver.onERC1155Received.selector,
            "UNSAFE_RECIPIENT"
        );
    }

    function _batchMint(
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        uint256 idsLength = ids.length; // Saves MLOADs.

        require(idsLength == amounts.length, "LENGTH_MISMATCH");

        for (uint256 i = 0; i < idsLength; ) {
            balanceOf[to][ids[i]] += amounts[i];

            // An array can't have a total length
            // larger than the max uint256 value.
            unchecked {
                ++i;
            }
        }

        emit TransferBatch(msg.sender, address(0), to, ids, amounts);

        require(
            to.code.length == 0
                ? to != address(0)
                : ERC1155TokenReceiver(to).onERC1155BatchReceived(msg.sender, address(0), ids, amounts, data) ==
                    ERC1155TokenReceiver.onERC1155BatchReceived.selector,
            "UNSAFE_RECIPIENT"
        );
    }

    function _batchBurn(
        address from,
        uint256[] memory ids,
        uint256[] memory amounts
    ) internal virtual {
        uint256 idsLength = ids.length; // Saves MLOADs.

        require(idsLength == amounts.length, "LENGTH_MISMATCH");

        for (uint256 i = 0; i < idsLength; ) {
            balanceOf[from][ids[i]] -= amounts[i];

            // An array can't have a total length
            // larger than the max uint256 value.
            unchecked {
                ++i;
            }
        }

        emit TransferBatch(msg.sender, from, address(0), ids, amounts);
    }

    function _burn(
        address from,
        uint256 id,
        uint256 amount
    ) internal virtual {
        balanceOf[from][id] -= amount;

        emit TransferSingle(msg.sender, from, address(0), id, amount);
    }
}

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

    function onERC1155BatchReceived(
        address,
        address,
        uint256[] calldata,
        uint256[] calldata,
        bytes calldata
    ) external virtual returns (bytes4) {
        return ERC1155TokenReceiver.onERC1155BatchReceived.selector;
    }
}

// SPDX-License-Identifier: UNLICENSE
pragma solidity 0.8.20;

import {Data} from "./Data.sol";
import {Base64} from "../lib/solady/src/utils/Base64.sol";
import {LibString} from "../lib/solady/src/utils/LibString.sol";
import {IFileStore} from "../lib/ethfs/packages/contracts/src/IFileStore.sol";

contract Collision {
    using LibString for uint256;

    IFileStore fileStore;
    string desc =
        '"description":"In a far away parallel universe an advanced civilization built a computer around a star and escaped into a simulated reality. After some immeasurable amount of time these facts were forgotten and after another immeasurable amount of time that star began to die. Even so, life Inside this simulation progressed, and on one planet some of that life progressed enough to form a government. You are the new member of a mysterious project under a secret agency of this government researching the elementary particles that make up your universe.",';

    constructor() {
        fileStore = IFileStore(0x9746fD0A77829E12F8A9DBe70D7a322412325B91);
    }

    function _parameters(uint256 _id) internal pure returns (string memory) {
        return
            string.concat(
                '<script src="data:text/javascript;base64,',
                Base64.encode(
                    abi.encodePacked(
                        string.concat(
                            "let seed = ",
                            _id.toString(),
                            _id == 0 ? "; let mode = 1;" : "; let mode = 0;"
                        )
                    )
                )
            );
    }

    function _scripts(uint256 _id) internal view returns (string memory) {
        return
            string.concat(
                '<script type="text/javascript+gzip" src="data:text/javascript;base64,',
                fileStore.getFile("p5-v1.5.0.min.js.gz").read(),
                '"></script>',
                '<script src="data:text/javascript;base64,',
                fileStore.getFile("gunzipScripts-0.0.1.js").read(),
                '"></script>',
                _parameters(_id),
                '"></script><script src="data:text/javascript;base64,',
                fileStore.getFile("(:").read(),
                '"></script>'
            );
    }

    function _page(uint256 _id) internal view returns (string memory) {
        return
            string.concat(
                '"animation_url":"data:text/html;base64,',
                Base64.encode(
                    abi.encodePacked(
                        string.concat(
                            '<!DOCTYPE html><html style="height: 100%;"><head>',
                            _scripts(_id),
                            '</head><body style="margin: 0;display: flex;justify-content: center;align-items: center;height: 100%;"></body></html>'
                        )
                    )
                ),
                '"}'
            );
    }

    function uri(uint256 _id) external view returns (string memory) {
        return
            string.concat(
                "data:application/json;base64,",
                Base64.encode(
                    abi.encodePacked(
                        string.concat(
                            '{"name":"< ',
                            _id > 0 ? _id.toString() : "...",
                            ' >",',
                            desc,
                            '"image":"',
                            Data._image(_id),
                            '",',
                            _page(_id)
                        )
                    )
                )
            );
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC2981.sol)

pragma solidity ^0.8.19;

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

/**
 * @dev Interface for the NFT Royalty Standard.
 *
 * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal
 * support for royalty payments across all NFT marketplaces and ecosystem participants.
 *
 * _Available since v4.5._
 */
interface IERC2981 is IERC165 {
    /**
     * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of
     * exchange. The royalty amount is denominated and should be paid in that same unit of exchange.
     */
    function royaltyInfo(
        uint256 tokenId,
        uint256 salePrice
    ) external view returns (address receiver, uint256 royaltyAmount);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.19;

import "./IERC165.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.13;

struct Content {
    bytes32 checksum;
    address pointer;
}

struct File {
    uint256 size; // content length in bytes, max 24k
    Content[] contents;
}

function read(File memory file) view returns (string memory contents) {
    Content[] memory chunks = file.contents;

    // Adapted from https://gist.github.com/xtremetom/20411eb126aaf35f98c8a8ffa00123cd
    assembly {
        let len := mload(chunks)
        let totalSize := 0x20
        contents := mload(0x40)
        let size
        let chunk
        let pointer

        // loop through all pointer addresses
        // - get content
        // - get address
        // - get data size
        // - get code and add to contents
        // - update total size

        for { let i := 0 } lt(i, len) { i := add(i, 1) } {
            chunk := mload(add(chunks, add(0x20, mul(i, 0x20))))
            pointer := mload(add(chunk, 0x20))

            size := sub(extcodesize(pointer), 1)
            extcodecopy(pointer, add(contents, totalSize), 1, size)
            totalSize := add(totalSize, size)
        }

        // update contents size
        mstore(contents, sub(totalSize, 0x20))
        // store contents
        mstore(0x40, add(contents, and(add(totalSize, 0x1f), not(0x1f))))
    }
}

using {read} for File global;

// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.13;

interface IContentStore {
    event NewChecksum(bytes32 indexed checksum, uint256 contentSize);

    error ChecksumExists(bytes32 checksum);
    error ChecksumNotFound(bytes32 checksum);

    function pointers(bytes32 checksum)
        external
        view
        returns (address pointer);

    function checksumExists(bytes32 checksum) external view returns (bool);

    function contentLength(bytes32 checksum)
        external
        view
        returns (uint256 size);

    function addPointer(address pointer) external returns (bytes32 checksum);

    function addContent(bytes memory content)
        external
        returns (bytes32 checksum, address pointer);

    function getPointer(bytes32 checksum)
        external
        view
        returns (address pointer);
}

// SPDX-License-Identifier: UNLICENSE
pragma solidity 0.8.20;

import {Base64} from "../lib/solady/src/utils/Base64.sol";
import {LibString} from "../lib/solady/src/utils/LibString.sol";

library Data {
    function _image(uint256 id) internal pure returns (string memory) {
        if (id > 0) {
            return _main(id);
        } else {
            return _$ECRET(id);
        }
    }

    function _main(uint256 id) internal pure returns (string memory) {
        string
            memory im = '<svg height="500" width="500" xmlns="http://www.w3.org/2000/svg"><rect x="0" y="0" width="500" height="500"/>';
        for (uint256 i; i < 26; ++i) {
            string memory y = LibString.toString((i * 20) + 10);
            im = string.concat(
                im,
                '<text fill="#FFF" font-size="20" font-family="monospace" x="250" y="',
                y,
                '" text-anchor="middle">',
                LibString.toHexStringNoPrefix(
                    abi.encode(
                        (keccak256(abi.encode(i, keccak256(abi.encode(id)))))
                    )
                ),
                '<animate attributeName="opacity" values="1;0;1" dur="1s" repeatCount="indefinite"/></text><text fill="#FFF" font-size="20" font-family="monospace" x="250" y="',
                y,
                '" text-anchor="middle">',
                LibString.toHexStringNoPrefix(
                    abi.encode(
                        (
                            keccak256(
                                abi.encode(i + 1, keccak256(abi.encode(id)))
                            )
                        )
                    )
                ),
                '<animate attributeName="opacity" values="0;1;0" dur="1s" repeatCount="indefinite"/></text><text fill="#FFF" font-size="20" font-family="monospace" x="250" y="',
                y,
                '" text-anchor="middle">',
                LibString.toHexStringNoPrefix(
                    abi.encode(
                        (
                            keccak256(
                                abi.encode(i + 2, keccak256(abi.encode(id)))
                            )
                        )
                    )
                ),
                '<animate attributeName="opacity" values="0;1;0" dur="2s" repeatCount="indefinite"/></text>'
            );
        }

        for (uint256 i; i < 11; ++i) {
            string memory y = LibString.toString((i * 50) + 25);
            im = string.concat(
                im,
                '<text fill="#000" font-size="80" font-family="monospace" x="250" y="',
                y,
                '" text-anchor="middle">',
                LibString.toHexStringNoPrefix(
                    abi.encode(
                        (keccak256(abi.encode(i, keccak256(abi.encode(id)))))
                    )
                ),
                '<animate attributeName="opacity" values="1;0;1" dur="1s" repeatCount="indefinite"/></text><text fill="#000" font-size="80" font-family="monospace" x="250" y="',
                y,
                '" text-anchor="middle">',
                LibString.toHexStringNoPrefix(
                    abi.encode(
                        (
                            keccak256(
                                abi.encode(i + 1, keccak256(abi.encode(id)))
                            )
                        )
                    )
                ),
                '<animate attributeName="opacity" values="0;1;0" dur="1s" repeatCount="indefinite"/></text><text fill="#000" font-size="80" font-family="monospace" x="250" y="',
                y,
                '" text-anchor="middle">',
                LibString.toHexStringNoPrefix(
                    abi.encode(
                        (
                            keccak256(
                                abi.encode(i + 2, keccak256(abi.encode(id)))
                            )
                        )
                    )
                ),
                '<animate attributeName="opacity" values="0;1;0" dur="2s" repeatCount="indefinite"/></text>'
            );
        }

        im = string.concat(im, "</svg>");
        return
            string.concat(
                "data:image/svg+xml;base64,",
                Base64.encode(bytes(im))
            );
    }

    function _$ECRET(uint256 id) internal pure returns (string memory) {
        string
            memory im = '<svg height="500" width="500" xmlns="http://www.w3.org/2000/svg">';
        for (uint256 i; i < 26; ++i) {
            string memory y = LibString.toString((i * 20) + 10);
            im = string.concat(
                im,
                '<text fill="#000" font-size="20" font-family="monospace" x="250" y="',
                y,
                '" text-anchor="middle">',
                LibString.toHexStringNoPrefix(
                    abi.encode(
                        (keccak256(abi.encode(i, keccak256(abi.encode(id)))))
                    )
                ),
                '<animate attributeName="opacity" values="1;0;1" dur="2s" repeatCount="indefinite"/></text><text fill="#000" font-size="20" font-family="monospace" x="250" y="',
                y,
                '" text-anchor="middle">',
                LibString.toHexStringNoPrefix(
                    abi.encode(
                        (
                            keccak256(
                                abi.encode(i + 1, keccak256(abi.encode(id)))
                            )
                        )
                    )
                ),
                '<animate attributeName="opacity" values="0;1;0" dur="2s" repeatCount="indefinite"/></text><text fill="#000" font-size="20" font-family="monospace" x="250" y="',
                y,
                '" text-anchor="middle">',
                LibString.toHexStringNoPrefix(
                    abi.encode(
                        (
                            keccak256(
                                abi.encode(i + 2, keccak256(abi.encode(id)))
                            )
                        )
                    )
                ),
                '<animate attributeName="opacity" values="0;1;0" dur="3s" repeatCount="indefinite"/></text>'
            );
        }

        for (uint256 i; i < 11; ++i) {
            string memory y = LibString.toString((i * 50) + 25);
            im = string.concat(
                im,
                '<text fill="#FFF" font-size="80" font-family="monospace" x="250" y="',
                y,
                '" text-anchor="middle">',
                LibString.toHexStringNoPrefix(
                    abi.encode(
                        (keccak256(abi.encode(i, keccak256(abi.encode(id)))))
                    )
                ),
                '<animate attributeName="opacity" values="1;0;1" dur="2s" repeatCount="indefinite"/></text><text fill="#FFF" font-size="80" font-family="monospace" x="250" y="',
                y,
                '" text-anchor="middle">',
                LibString.toHexStringNoPrefix(
                    abi.encode(
                        (
                            keccak256(
                                abi.encode(i + 1, keccak256(abi.encode(id)))
                            )
                        )
                    )
                ),
                '<animate attributeName="opacity" values="0;1;0" dur="2s" repeatCount="indefinite"/></text><text fill="#FFF" font-size="80" font-family="monospace" x="250" y="',
                y,
                '" text-anchor="middle">',
                LibString.toHexStringNoPrefix(
                    abi.encode(
                        (
                            keccak256(
                                abi.encode(i + 2, keccak256(abi.encode(id)))
                            )
                        )
                    )
                ),
                '<animate attributeName="opacity" values="0;1;0" dur="3s" repeatCount="indefinite"/></text>'
            );
        }

        im = string.concat(
            im,
            '<text fill="#F00" font-size="80" font-family="monospace" x="420" y="275" text-anchor="middle">&lt; &gt;</text></svg>'
        );
        return
            string.concat(
                "data:image/svg+xml;base64,",
                Base64.encode(bytes(im))
            );
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.19;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

{
  "remappings": [
    "ds-test/=lib/solady/lib/ds-test/src/",
    "ethfs/=lib/ethfs/",
    "ethier/=lib/ethfs/packages/contracts/lib/ethier/",
    "forge-std/=lib/forge-std/src/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/",
    "openzeppelin/=lib/openzeppelin-contracts/contracts/",
    "solady/=lib/solady/src/",
    "solmate/=lib/solmate/src/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 1000000
  },
  "metadata": {
    "bytecodeHash": "none",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "paris",
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"uint256","name":"_startTime","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"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":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"anti","outputs":[{"internalType":"contract Antigraviton","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"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":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"claimAnti","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"claimed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"string","name":"signal","type":"string"}],"name":"collide","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"currentId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"invert","outputs":[],"stateMutability":"nonpayable","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":"","type":"uint256"}],"name":"level","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256[][]","name":"arr","type":"uint256[][]"}],"name":"observe","outputs":[],"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":"uint256","name":"","type":"uint256"}],"name":"prestige","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"prism","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"program","outputs":[{"internalType":"contract Program","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"redacted","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"research","outputs":[{"internalType":"contract Research","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"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":"uint256","name":"","type":"uint256"}],"name":"seed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"spin","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"startTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":"id","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":"uint256","name":"id","type":"uint256"}],"name":"virtualAnti","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"xe","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000000aa0bc25769c52e623d09a9764e079a221bea2a100000000000000000000000000000000000000000000000000000000649dc6a0

-----Decoded View---------------
Arg [0] : _owner (address): 0x0aa0Bc25769C52e623D09A9764e079A221BeA2a1
Arg [1] : _startTime (uint256): 1688061600

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000000aa0bc25769c52e623d09a9764e079a221bea2a1
Arg [1] : 00000000000000000000000000000000000000000000000000000000649dc6a0