{"sources":{"contracts/lib/render/Render.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.28;\n\ninterface IRender {\n function tokenURI(uint256 id) external view returns (string memory);\n}"},"contracts/lib/report/IReportRoot.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\npragma solidity ^0.8.28;\n\ninterface IReportRoot {\n function report(address _from, uint256 _value) external payable;\n function split() external;\n function splitEnd() external;\n function end() external;\n}"},"contracts/lib/report/ReportRoot.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.28;\n\nimport \"./IReportRoot.sol\";\n\ncontract ReportRootVariable is IReportRoot {\n event Activation(address indexed sender);\n\n struct Metadata {\n uint timestamp;\n address sender;\n }\n\n uint256 constant RESERVED_BYTES = 12;\n uint8 immutable public INDEX_BYTES;\n uint256 immutable SPLIT_START;\n uint256 immutable SPLIT_END;\n\n uint256 public totalReports;\n mapping (uint256 => bytes32[]) public reports;\n mapping (uint256 => Metadata) public metadata;\n\n constructor(uint8 _indexBytes) {\n require(_indexBytes == 1 || _indexBytes == 2 || _indexBytes == 4, \"Invalid INDEX_BYTES\");\n INDEX_BYTES = _indexBytes;\n SPLIT_START = _indexBytes == 4 ? type(uint32).max : _indexBytes == 2 ? type(uint16).max : type(uint8).max;\n SPLIT_END = _indexBytes == 4 ? type(uint32).max - 1 : _indexBytes == 2 ? type(uint16).max - 1 : type(uint8).max - 1;\n }\n\n\n function getReport(uint256 _index) public view returns (bytes32[] memory, Metadata memory) {\n return (reports[_index], metadata[_index]);\n }\n\n function getMostRecentReport() public view returns (bytes32[] memory, Metadata memory) {\n if (totalReports == 0) {\n return (new bytes32[](0), Metadata({ timestamp: 0, sender: address(0) }));\n }\n return (reports[totalReports-1], metadata[totalReports-1]);\n }\n\n function begin(address sender) internal {\n assembly {\n tstore(1, 1) // Set the running flag to true\n tstore(2, add(tload(2), 1)) // Increment the run counter\n tstore(5, sender)\n }\n }\n\n // The report function that stores \"from\" and \"to\" indices transiently\n function report(address _from, uint256 _value) public payable {\n uint256 reportIndex;\n assembly {\n reportIndex := tload(0)\n }\n\n uint32 fromIndex = getTransientIndex(_from);\n uint32 toIndex = getTransientIndex(msg.sender);\n\n uint8 reportsPerBuffer = 32 / (INDEX_BYTES * 2);\n // Each buffer holds X reports. Except the first one, so we add RESERVED_BYTES/2 to the report index\n uint256 bufferIndex = (reportIndex + (RESERVED_BYTES/(INDEX_BYTES * 2))) / reportsPerBuffer;\n // Position within the current buffer (0-15)\n uint256 positionInBuffer = (reportIndex + (RESERVED_BYTES/(INDEX_BYTES * 2))) % reportsPerBuffer;\n\n // Load the current buffer from transient storage\n bytes32 currentBuffer;\n assembly {\n currentBuffer := tload(add(add(1000000000,tload(2)),bufferIndex))\n }\n\n // Encode the \"from\" and \"to\" indices in the buffer\n currentBuffer |= bytes32(uint256(fromIndex) << ((positionInBuffer * INDEX_BYTES * 2) * 8))\n | bytes32(uint256(toIndex) << ((positionInBuffer * INDEX_BYTES * 2 + INDEX_BYTES) * 8));\n\n // Store the updated buffer back in transient storage\n assembly {\n tstore(add(add(1000000000,tload(2)),bufferIndex), currentBuffer)\n tstore(0, add(1, reportIndex))\n }\n }\n\n function getTransientIndex(address _address) internal returns (uint32) {\n uint32 addressIndex;\n uint32 nextAvailableIndex;\n uint256 run;\n assembly {\n run := tload(2)\n }\n bytes32 slot = keccak256(abi.encodePacked(_address, run));\n\n // Check if the address already has an index in transient storage or assign one\n assembly {\n // Use the keccak256 hash to calculate a unique slot for the address\n addressIndex := tload(slot)\n\n // If the address doesn't have an index yet (addressIndex is 0), assign one\n if eq(addressIndex, 0) {\n // Load the next available index from a specific slot (e.g., 4)\n nextAvailableIndex := tload(3)\n\n // Indices start at 1 (0 is reserved for \"not set\")\n if eq(nextAvailableIndex, 0) {\n nextAvailableIndex := 1\n }\n\n // Assign the new index to the address\n addressIndex := nextAvailableIndex\n\n\n // Increment the next available index and store it back in slot 4\n tstore(3, add(nextAvailableIndex, 1))\n\n // Store this new index in transient storage for the address\n tstore(slot, addressIndex)\n }\n }\n\n return addressIndex;\n }\n\n function split() public {\n uint256 reportIndex;\n assembly {\n reportIndex := tload(0)\n }\n\n uint8 reportsPerBuffer = 32 / (INDEX_BYTES * 2);\n uint256 bufferIndex = (reportIndex + (RESERVED_BYTES/(INDEX_BYTES * 2))) / reportsPerBuffer;\n uint256 positionInBuffer = (reportIndex + (RESERVED_BYTES/(INDEX_BYTES * 2))) % reportsPerBuffer;\n\n bytes32 currentBuffer;\n assembly {\n currentBuffer := tload(add(add(1000000000,tload(2)),bufferIndex))\n }\n\n currentBuffer |= bytes32(uint256(SPLIT_START) << ((positionInBuffer * INDEX_BYTES * 2) * 8))\n | bytes32(uint256(SPLIT_START) << ((positionInBuffer * INDEX_BYTES * 2 + INDEX_BYTES) * 8));\n // Theoretically we could use this second index for something else\n // e.g. to store the number of the current split\n\n assembly {\n tstore(add(add(1000000000,tload(2)),bufferIndex), currentBuffer) // Store the updated buffer\n tstore(0, add(1, reportIndex)) // Increment the report index\n tstore(4, add(1, tload(4))) // Increment the split index\n }\n }\n\n function splitEnd() public {\n uint256 reportIndex;\n assembly {\n reportIndex := tload(0)\n }\n\n uint8 reportsPerBuffer = 32 / (INDEX_BYTES * 2);\n uint256 bufferIndex = (reportIndex + (RESERVED_BYTES/(INDEX_BYTES * 2))) / reportsPerBuffer;\n uint256 positionInBuffer = (reportIndex + (RESERVED_BYTES/(INDEX_BYTES * 2))) % reportsPerBuffer;\n\n bytes32 currentBuffer;\n assembly {\n currentBuffer := tload(add(add(1000000000,tload(2)),bufferIndex))\n }\n\n currentBuffer |= bytes32(uint256(SPLIT_END) << ((positionInBuffer * INDEX_BYTES * 2) * 8))\n | bytes32(uint256(SPLIT_END) << ((positionInBuffer * INDEX_BYTES * 2 + INDEX_BYTES) * 8));\n // Theoretically we could use this second index for something else\n // e.g. to store the number of the current split\n\n assembly {\n tstore(add(add(1000000000,tload(2)),bufferIndex), currentBuffer)\n tstore(0, add(1, reportIndex))\n }\n }\n\n function end() public {\n uint256 reportIndex;\n uint256 addressCount;\n uint256 splitCount;\n address sender;\n assembly {\n if eq(tload(1), 0) {\n revert(0, 0)\n }\n reportIndex := tload(0)\n addressCount := sub(tload(3),1)\n splitCount := tload(4)\n sender := tload(5)\n }\n\n uint8 reportsPerBuffer = 32 / (INDEX_BYTES * 2);\n uint256 totalBuffers = (reportIndex + (RESERVED_BYTES/(INDEX_BYTES * 2)) + (reportsPerBuffer - 1)) / reportsPerBuffer; // Round up to account for partial buffers\n\n bytes32[] memory buffers = new bytes32[](totalBuffers);\n for (uint256 bufferIndex = 0; bufferIndex < totalBuffers; bufferIndex++) {\n bytes32 currentBuffer;\n assembly {\n currentBuffer := tload(add(add(1000000000,tload(2)),bufferIndex))\n }\n if (bufferIndex == 0) {\n // Byte 1: how many bytes per index (1 byte)\n // Byte 2-4: is the total number of addresses (3 bytes)\n // Byte 5-8: the next 4 bytes is the number of reports (4 bytes)\n // Byte 9-12: the next 4 bytes is the split index (4 bytes)\n currentBuffer |= bytes32(uint256(INDEX_BYTES))\n | bytes32(uint256(addressCount) << (1 * 8))\n | bytes32(uint256(uint32(reportIndex)) << (4 * 8))\n | bytes32(uint256(uint32(splitCount)) << (8 * 8));\n }\n buffers[bufferIndex] = currentBuffer;\n }\n\n reports[totalReports] = buffers;\n metadata[totalReports] = Metadata({ timestamp: block.timestamp, sender: sender });\n totalReports++;\n\n // Clear the transient storage by resetting the index to zero\n assembly {\n tstore(0, 0) // Reset the report index\n tstore(1, 0) // Reset the running flag\n tstore(3, 0) // Reset the nextAvailableIndex\n tstore(4, 0) // Reset the split count\n }\n\n emit Activation(tx.origin);\n }\n}\n\ncontract ReportRoot is ReportRootVariable {\n constructor() ReportRootVariable(1) {}\n}\n"},"contracts/lib/report/TxReport.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\npragma solidity ^0.8.28;\n\nimport \"./IReportRoot.sol\";\n\nabstract contract TxReport {\n\n address immutable root;\n\n constructor(address _root) {\n root = _root;\n }\n\n fallback() external payable {\n if (msg.sender != root) {\n IReportRoot(root).report(msg.sender, msg.value);\n }\n onReceive();\n }\n\n function onReceive() internal virtual;\n}"},"contracts/lib/sculpture/ITransactionSculpture.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.8.0;\n\n////////////////////////////////////////////////////////////////////////\n// //\n// //\n// //\n// //\n// //\n// //\n// //\n// //\n// |--|__| //\n// transaction sculpture //\n// //\n// //\n// //\n// //\n// //\n// //\n// //\n// //\n////////////////////////////////////////////////////////////////////////\n\nimport \"./Sculpture.sol\";\n\ninterface ITransactionSculpture is Sculpture {\n\n function id() external view returns (uint256);\n\n function owner() external view returns (address);\n\n}\n"},"contracts/lib/sculpture/Sculpture.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.8.0;\n\n////////////////////////////////////////////////////////////////////////\n// //\n// //\n// //\n// //\n// //\n// //\n// //\n// //\n// ⚘ //\n// sculpture //\n// //\n// //\n// //\n// //\n// //\n// //\n// //\n// //\n////////////////////////////////////////////////////////////////////////\n\ninterface Sculpture {\n\n function title() external view returns (string memory);\n\n function authors() external view returns (string[] memory);\n\n function addresses() external view returns (address[] memory);\n\n function urls() external view returns (string[] memory);\n\n function text() external view returns (string memory);\n\n}\n"},"contracts/lib/sculpture/TransactionSculpture.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity >=0.8.0;\n\n////////////////////////////////////////////////////////////////////////\n// //\n// //\n// //\n// //\n// //\n// //\n// //\n// //\n// |--|__| //\n// transaction sculpture //\n// //\n// //\n// //\n// //\n// //\n// //\n// //\n// //\n////////////////////////////////////////////////////////////////////////\n\nimport \"solady/src/tokens/ERC721.sol\";\nimport \"solady/src/utils/Base64.sol\";\nimport \"solady/src/utils/LibString.sol\";\nimport \"./ITransactionSculpture.sol\";\nimport \"../report/ReportRoot.sol\";\nimport \"../render/Render.sol\";\n\nabstract contract TransactionSculpture is ITransactionSculpture, ERC721, ReportRoot {\n address public render;\n\n constructor() {\n _mint(msg.sender, id());\n }\n\n function setRender(address _render) external virtual {\n require(_render == address(0));\n require(msg.sender == ownerOf(id()));\n render = _render;\n }\n\n function withdraw() external virtual {\n require(msg.sender == ownerOf(id()));\n (bool sent, ) = msg.sender.call{value: address(this).balance}(\"\");\n require(sent);\n }\n\n ///////////////////////////////////////////////////////////////////////////\n // Transaction Sculpture\n ///////////////////////////////////////////////////////////////////////////\n\n function id() public pure virtual returns (uint256);\n\n function addresses() public view virtual returns(address[] memory addrs) {\n addrs = new address[](1);\n addrs[0] = address(this);\n }\n\n function owner() external view virtual returns (address) {\n return _ownerOf(id());\n }\n\n ///////////////////////////////////////////////////////////////////////////\n // Sculpture\n ///////////////////////////////////////////////////////////////////////////\n\n function title() public view virtual returns (string memory) {\n return \"Untitled\";\n }\n\n function authors() external view virtual returns (string[] memory authors_) {\n authors_ = new string[](1);\n authors_[0] = '0xfff';\n }\n\n function urls() external view virtual returns (string[] memory urls_) { return urls_; }\n\n function text() external view virtual returns (string memory) { return \"\"; }\n\n ///////////////////////////////////////////////////////////////////////////\n // ERC721\n ///////////////////////////////////////////////////////////////////////////\n\n function name() public view override returns (string memory) {\n return title();\n }\n\n function symbol() public view override returns (string memory) {\n return string.concat(\"TX\", LibString.toString(id()));\n }\n\n function tokenURI(uint256 id) public view override returns (string memory) {\n if (render == address(0)) return \"\";\n IRender(render).tokenURI(id);\n }\n}"},"contracts/lib/tx/RandomForward.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.28;\n\nimport \"../report/TxReport.sol\";\nimport \"../util/TransientRandomness.sol\";\n\ninterface IRandomForward {\n function setRandomForwards(address[] memory _forwards) external;\n}\n\ncontract RandomForward is IRandomForward, TxReport, TransientRandomness {\n address[] public forwards;\n uint256 immutable public chance;\n\n constructor(uint256 _chance) TxReport(msg.sender) {\n chance = _chance;\n }\n\n function setRandomForwards(address[] memory _forwards) external {\n require(msg.sender == root);\n forwards = _forwards;\n }\n\n function onReceive() internal override {\n if (random() % 100 < chance || msg.sender == root) {\n uint256 index = random() % forwards.length;\n (bool sent, ) = forwards[index].call{value: msg.value}(\"\");\n require(sent);\n } else {\n (bool sent, ) = tx.origin.call{value: msg.value}(\"\");\n require(sent);\n }\n }\n}"},"contracts/lib/util/TransientRandomness.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.28;\n\ncontract TransientRandomness {\n // we need a source of randomness that uses a nonce to increment the randomness, stored transiently using tstore/tload\n function random() internal returns (uint256) {\n uint256 nonce;\n assembly {\n nonce := tload(0)\n nonce := add(nonce, 1)\n tstore(0, nonce)\n }\n return uint256(keccak256(abi.encodePacked(block.timestamp, block.prevrandao, nonce, address(this))));\n }\n}"},"contracts/sculptures/Untitled.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.28;\n\n////////////////////////////////////////////////////////////////////////\n// //\n// //\n// //\n// //\n// //\n// //\n// //\n// //\n// |--|__| //\n// //\n// 0 //\n// //\n// //\n// //\n// //\n// //\n// //\n// //\n////////////////////////////////////////////////////////////////////////\n\nimport \"../lib/sculpture/TransactionSculpture.sol\";\nimport \"../lib/tx/RandomForward.sol\";\n\ncontract Untitled is TransactionSculpture {\n\n address[] public forwards;\n\n constructor() {\n forwards = new address[](12);\n\n for (uint256 i = 0; i < 12; i++) {\n forwards[i] = address(new RandomForward(96));\n }\n\n for (uint256 i = 0; i < 12; i++) {\n address[] memory forwards_ = new address[](12-1);\n for (uint256 j = 0; j < 12-1; j++) {\n forwards_[j] = forwards[(i + j + 1) % 12];\n }\n IRandomForward(forwards[i]).setRandomForwards(forwards_);\n }\n }\n\n receive() external payable {\n begin(msg.sender);\n\n uint256 index = uint256(keccak256(abi.encodePacked(block.timestamp, block.prevrandao, msg.sender, msg.value))) % forwards.length;\n (bool sent, ) = address(forwards[index]).call{value: msg.value}(\"\");\n require(sent, \"Could not forward\");\n\n end();\n }\n\n function id() public pure override returns (uint256) { return 0; }\n\n function title() public view override returns (string memory) {\n return \"Untitled (Transaction Sculpture)\";\n }\n\n function text() external view override returns (string memory) { return unicode\"| ||||||||||||\"; }\n\n}"},"solady/src/tokens/ERC721.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Simple ERC721 implementation with storage hitchhiking.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/tokens/ERC721.sol)\n/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC721.sol)\n/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC721/ERC721.sol)\n///\n/// @dev Note:\n/// - The ERC721 standard allows for self-approvals.\n/// For performance, this implementation WILL NOT revert for such actions.\n/// Please add any checks with overrides if desired.\n/// - For performance, methods are made payable where permitted by the ERC721 standard.\n/// - The `safeTransfer` functions use the identity precompile (0x4)\n/// to copy memory internally.\n///\n/// If you are overriding:\n/// - NEVER violate the ERC721 invariant:\n/// the balance of an owner MUST always be equal to their number of ownership slots.\n/// The transfer functions do not have an underflow guard for user token balances.\n/// - Make sure all variables written to storage are properly cleaned\n// (e.g. the bool value for `isApprovedForAll` MUST be either 1 or 0 under the hood).\n/// - Check that the overridden function is actually used in the function you want to\n/// change the behavior of. Much of the code has been manually inlined for performance.\nabstract contract ERC721 {\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* CONSTANTS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev An account can hold up to 4294967295 tokens.\n uint256 internal constant _MAX_ACCOUNT_BALANCE = 0xffffffff;\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* CUSTOM ERRORS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Only the token owner or an approved account can manage the token.\n error NotOwnerNorApproved();\n\n /// @dev The token does not exist.\n error TokenDoesNotExist();\n\n /// @dev The token already exists.\n error TokenAlreadyExists();\n\n /// @dev Cannot query the balance for the zero address.\n error BalanceQueryForZeroAddress();\n\n /// @dev Cannot mint or transfer to the zero address.\n error TransferToZeroAddress();\n\n /// @dev The token must be owned by `from`.\n error TransferFromIncorrectOwner();\n\n /// @dev The recipient's balance has overflowed.\n error AccountBalanceOverflow();\n\n /// @dev Cannot safely transfer to a contract that does not implement\n /// the ERC721Receiver interface.\n error TransferToNonERC721ReceiverImplementer();\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* EVENTS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Emitted when token `id` is transferred from `from` to `to`.\n event Transfer(address indexed from, address indexed to, uint256 indexed id);\n\n /// @dev Emitted when `owner` enables `account` to manage the `id` token.\n event Approval(address indexed owner, address indexed account, uint256 indexed id);\n\n /// @dev Emitted when `owner` enables or disables `operator` to manage all of their tokens.\n event ApprovalForAll(address indexed owner, address indexed operator, bool isApproved);\n\n /// @dev `keccak256(bytes(\"Transfer(address,address,uint256)\"))`.\n uint256 private constant _TRANSFER_EVENT_SIGNATURE =\n 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;\n\n /// @dev `keccak256(bytes(\"Approval(address,address,uint256)\"))`.\n uint256 private constant _APPROVAL_EVENT_SIGNATURE =\n 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925;\n\n /// @dev `keccak256(bytes(\"ApprovalForAll(address,address,bool)\"))`.\n uint256 private constant _APPROVAL_FOR_ALL_EVENT_SIGNATURE =\n 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31;\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* STORAGE */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev The ownership data slot of `id` is given by:\n /// ```\n /// mstore(0x00, id)\n /// mstore(0x1c, _ERC721_MASTER_SLOT_SEED)\n /// let ownershipSlot := add(id, add(id, keccak256(0x00, 0x20)))\n /// ```\n /// Bits Layout:\n /// - [0..159] `addr`\n /// - [160..255] `extraData`\n ///\n /// The approved address slot is given by: `add(1, ownershipSlot)`.\n ///\n /// See: https://notes.ethereum.org/%40vbuterin/verkle_tree_eip\n ///\n /// The balance slot of `owner` is given by:\n /// ```\n /// mstore(0x1c, _ERC721_MASTER_SLOT_SEED)\n /// mstore(0x00, owner)\n /// let balanceSlot := keccak256(0x0c, 0x1c)\n /// ```\n /// Bits Layout:\n /// - [0..31] `balance`\n /// - [32..255] `aux`\n ///\n /// The `operator` approval slot of `owner` is given by:\n /// ```\n /// mstore(0x1c, or(_ERC721_MASTER_SLOT_SEED, operator))\n /// mstore(0x00, owner)\n /// let operatorApprovalSlot := keccak256(0x0c, 0x30)\n /// ```\n uint256 private constant _ERC721_MASTER_SLOT_SEED = 0x7d8825530a5a2e7a << 192;\n\n /// @dev Pre-shifted and pre-masked constant.\n uint256 private constant _ERC721_MASTER_SLOT_SEED_MASKED = 0x0a5a2e7a00000000;\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* ERC721 METADATA */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Returns the token collection name.\n function name() public view virtual returns (string memory);\n\n /// @dev Returns the token collection symbol.\n function symbol() public view virtual returns (string memory);\n\n /// @dev Returns the Uniform Resource Identifier (URI) for token `id`.\n function tokenURI(uint256 id) public view virtual returns (string memory);\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* ERC721 */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Returns the owner of token `id`.\n ///\n /// Requirements:\n /// - Token `id` must exist.\n function ownerOf(uint256 id) public view virtual returns (address result) {\n result = _ownerOf(id);\n /// @solidity memory-safe-assembly\n assembly {\n if iszero(result) {\n mstore(0x00, 0xceea21b6) // `TokenDoesNotExist()`.\n revert(0x1c, 0x04)\n }\n }\n }\n\n /// @dev Returns the number of tokens owned by `owner`.\n ///\n /// Requirements:\n /// - `owner` must not be the zero address.\n function balanceOf(address owner) public view virtual returns (uint256 result) {\n /// @solidity memory-safe-assembly\n assembly {\n // Revert if the `owner` is the zero address.\n if iszero(owner) {\n mstore(0x00, 0x8f4eb604) // `BalanceQueryForZeroAddress()`.\n revert(0x1c, 0x04)\n }\n mstore(0x1c, _ERC721_MASTER_SLOT_SEED)\n mstore(0x00, owner)\n result := and(sload(keccak256(0x0c, 0x1c)), _MAX_ACCOUNT_BALANCE)\n }\n }\n\n /// @dev Returns the account approved to manage token `id`.\n ///\n /// Requirements:\n /// - Token `id` must exist.\n function getApproved(uint256 id) public view virtual returns (address result) {\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, id)\n mstore(0x1c, _ERC721_MASTER_SLOT_SEED)\n let ownershipSlot := add(id, add(id, keccak256(0x00, 0x20)))\n if iszero(shl(96, sload(ownershipSlot))) {\n mstore(0x00, 0xceea21b6) // `TokenDoesNotExist()`.\n revert(0x1c, 0x04)\n }\n result := sload(add(1, ownershipSlot))\n }\n }\n\n /// @dev Sets `account` as the approved account to manage token `id`.\n ///\n /// Requirements:\n /// - Token `id` must exist.\n /// - The caller must be the owner of the token,\n /// or an approved operator for the token owner.\n ///\n /// Emits an {Approval} event.\n function approve(address account, uint256 id) public payable virtual {\n _approve(msg.sender, account, id);\n }\n\n /// @dev Returns whether `operator` is approved to manage the tokens of `owner`.\n function isApprovedForAll(address owner, address operator)\n public\n view\n virtual\n returns (bool result)\n {\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x1c, operator)\n mstore(0x08, _ERC721_MASTER_SLOT_SEED_MASKED)\n mstore(0x00, owner)\n result := sload(keccak256(0x0c, 0x30))\n }\n }\n\n /// @dev Sets whether `operator` is approved to manage the tokens of the caller.\n ///\n /// Emits an {ApprovalForAll} event.\n function setApprovalForAll(address operator, bool isApproved) public virtual {\n /// @solidity memory-safe-assembly\n assembly {\n // Convert to 0 or 1.\n isApproved := iszero(iszero(isApproved))\n // Update the `isApproved` for (`msg.sender`, `operator`).\n mstore(0x1c, operator)\n mstore(0x08, _ERC721_MASTER_SLOT_SEED_MASKED)\n mstore(0x00, caller())\n sstore(keccak256(0x0c, 0x30), isApproved)\n // Emit the {ApprovalForAll} event.\n mstore(0x00, isApproved)\n // forgefmt: disable-next-item\n log3(0x00, 0x20, _APPROVAL_FOR_ALL_EVENT_SIGNATURE, caller(), shr(96, shl(96, operator)))\n }\n }\n\n /// @dev Transfers token `id` from `from` to `to`.\n ///\n /// Requirements:\n ///\n /// - Token `id` must exist.\n /// - `from` must be the owner of the token.\n /// - `to` cannot be the zero address.\n /// - The caller must be the owner of the token, or be approved to manage the token.\n ///\n /// Emits a {Transfer} event.\n function transferFrom(address from, address to, uint256 id) public payable virtual {\n _beforeTokenTransfer(from, to, id);\n /// @solidity memory-safe-assembly\n assembly {\n // Clear the upper 96 bits.\n let bitmaskAddress := shr(96, not(0))\n from := and(bitmaskAddress, from)\n to := and(bitmaskAddress, to)\n // Load the ownership data.\n mstore(0x00, id)\n mstore(0x1c, or(_ERC721_MASTER_SLOT_SEED, caller()))\n let ownershipSlot := add(id, add(id, keccak256(0x00, 0x20)))\n let ownershipPacked := sload(ownershipSlot)\n let owner := and(bitmaskAddress, ownershipPacked)\n // Revert if the token does not exist, or if `from` is not the owner.\n if iszero(mul(owner, eq(owner, from))) {\n // `TokenDoesNotExist()`, `TransferFromIncorrectOwner()`.\n mstore(shl(2, iszero(owner)), 0xceea21b6a1148100)\n revert(0x1c, 0x04)\n }\n // Load, check, and update the token approval.\n {\n mstore(0x00, from)\n let approvedAddress := sload(add(1, ownershipSlot))\n // Revert if the caller is not the owner, nor approved.\n if iszero(or(eq(caller(), from), eq(caller(), approvedAddress))) {\n if iszero(sload(keccak256(0x0c, 0x30))) {\n mstore(0x00, 0x4b6e7f18) // `NotOwnerNorApproved()`.\n revert(0x1c, 0x04)\n }\n }\n // Delete the approved address if any.\n if approvedAddress { sstore(add(1, ownershipSlot), 0) }\n }\n // Update with the new owner.\n sstore(ownershipSlot, xor(ownershipPacked, xor(from, to)))\n // Decrement the balance of `from`.\n {\n let fromBalanceSlot := keccak256(0x0c, 0x1c)\n sstore(fromBalanceSlot, sub(sload(fromBalanceSlot), 1))\n }\n // Increment the balance of `to`.\n {\n mstore(0x00, to)\n let toBalanceSlot := keccak256(0x0c, 0x1c)\n let toBalanceSlotPacked := add(sload(toBalanceSlot), 1)\n // Revert if `to` is the zero address, or if the account balance overflows.\n if iszero(mul(to, and(toBalanceSlotPacked, _MAX_ACCOUNT_BALANCE))) {\n // `TransferToZeroAddress()`, `AccountBalanceOverflow()`.\n mstore(shl(2, iszero(to)), 0xea553b3401336cea)\n revert(0x1c, 0x04)\n }\n sstore(toBalanceSlot, toBalanceSlotPacked)\n }\n // Emit the {Transfer} event.\n log4(codesize(), 0x00, _TRANSFER_EVENT_SIGNATURE, from, to, id)\n }\n _afterTokenTransfer(from, to, id);\n }\n\n /// @dev Equivalent to `safeTransferFrom(from, to, id, \"\")`.\n function safeTransferFrom(address from, address to, uint256 id) public payable virtual {\n transferFrom(from, to, id);\n if (_hasCode(to)) _checkOnERC721Received(from, to, id, \"\");\n }\n\n /// @dev Transfers token `id` from `from` to `to`.\n ///\n /// Requirements:\n ///\n /// - Token `id` must exist.\n /// - `from` must be the owner of the token.\n /// - `to` cannot be the zero address.\n /// - The caller must be the owner of the token, or be approved to manage the token.\n /// - If `to` refers to a smart contract, it must implement\n /// {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n ///\n /// Emits a {Transfer} event.\n function safeTransferFrom(address from, address to, uint256 id, bytes calldata data)\n public\n payable\n virtual\n {\n transferFrom(from, to, id);\n if (_hasCode(to)) _checkOnERC721Received(from, to, id, data);\n }\n\n /// @dev Returns true if this contract implements the interface defined by `interfaceId`.\n /// See: https://eips.ethereum.org/EIPS/eip-165\n /// This function call must use less than 30000 gas.\n function supportsInterface(bytes4 interfaceId) public view virtual returns (bool result) {\n /// @solidity memory-safe-assembly\n assembly {\n let s := shr(224, interfaceId)\n // ERC165: 0x01ffc9a7, ERC721: 0x80ac58cd, ERC721Metadata: 0x5b5e139f.\n result := or(or(eq(s, 0x01ffc9a7), eq(s, 0x80ac58cd)), eq(s, 0x5b5e139f))\n }\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* INTERNAL QUERY FUNCTIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Returns if token `id` exists.\n function _exists(uint256 id) internal view virtual returns (bool result) {\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, id)\n mstore(0x1c, _ERC721_MASTER_SLOT_SEED)\n result := iszero(iszero(shl(96, sload(add(id, add(id, keccak256(0x00, 0x20)))))))\n }\n }\n\n /// @dev Returns the owner of token `id`.\n /// Returns the zero address instead of reverting if the token does not exist.\n function _ownerOf(uint256 id) internal view virtual returns (address result) {\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, id)\n mstore(0x1c, _ERC721_MASTER_SLOT_SEED)\n result := shr(96, shl(96, sload(add(id, add(id, keccak256(0x00, 0x20))))))\n }\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* INTERNAL DATA HITCHHIKING FUNCTIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n // For performance, no events are emitted for the hitchhiking setters.\n // Please emit your own events if required.\n\n /// @dev Returns the auxiliary data for `owner`.\n /// Minting, transferring, burning the tokens of `owner` will not change the auxiliary data.\n /// Auxiliary data can be set for any address, even if it does not have any tokens.\n function _getAux(address owner) internal view virtual returns (uint224 result) {\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x1c, _ERC721_MASTER_SLOT_SEED)\n mstore(0x00, owner)\n result := shr(32, sload(keccak256(0x0c, 0x1c)))\n }\n }\n\n /// @dev Set the auxiliary data for `owner` to `value`.\n /// Minting, transferring, burning the tokens of `owner` will not change the auxiliary data.\n /// Auxiliary data can be set for any address, even if it does not have any tokens.\n function _setAux(address owner, uint224 value) internal virtual {\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x1c, _ERC721_MASTER_SLOT_SEED)\n mstore(0x00, owner)\n let balanceSlot := keccak256(0x0c, 0x1c)\n let packed := sload(balanceSlot)\n sstore(balanceSlot, xor(packed, shl(32, xor(value, shr(32, packed)))))\n }\n }\n\n /// @dev Returns the extra data for token `id`.\n /// Minting, transferring, burning a token will not change the extra data.\n /// The extra data can be set on a non-existent token.\n function _getExtraData(uint256 id) internal view virtual returns (uint96 result) {\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, id)\n mstore(0x1c, _ERC721_MASTER_SLOT_SEED)\n result := shr(160, sload(add(id, add(id, keccak256(0x00, 0x20)))))\n }\n }\n\n /// @dev Sets the extra data for token `id` to `value`.\n /// Minting, transferring, burning a token will not change the extra data.\n /// The extra data can be set on a non-existent token.\n function _setExtraData(uint256 id, uint96 value) internal virtual {\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, id)\n mstore(0x1c, _ERC721_MASTER_SLOT_SEED)\n let ownershipSlot := add(id, add(id, keccak256(0x00, 0x20)))\n let packed := sload(ownershipSlot)\n sstore(ownershipSlot, xor(packed, shl(160, xor(value, shr(160, packed)))))\n }\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* INTERNAL MINT FUNCTIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Mints token `id` to `to`.\n ///\n /// Requirements:\n ///\n /// - Token `id` must not exist.\n /// - `to` cannot be the zero address.\n ///\n /// Emits a {Transfer} event.\n function _mint(address to, uint256 id) internal virtual {\n _beforeTokenTransfer(address(0), to, id);\n /// @solidity memory-safe-assembly\n assembly {\n // Clear the upper 96 bits.\n to := shr(96, shl(96, to))\n // Load the ownership data.\n mstore(0x00, id)\n mstore(0x1c, _ERC721_MASTER_SLOT_SEED)\n let ownershipSlot := add(id, add(id, keccak256(0x00, 0x20)))\n let ownershipPacked := sload(ownershipSlot)\n // Revert if the token already exists.\n if shl(96, ownershipPacked) {\n mstore(0x00, 0xc991cbb1) // `TokenAlreadyExists()`.\n revert(0x1c, 0x04)\n }\n // Update with the owner.\n sstore(ownershipSlot, or(ownershipPacked, to))\n // Increment the balance of the owner.\n {\n mstore(0x00, to)\n let balanceSlot := keccak256(0x0c, 0x1c)\n let balanceSlotPacked := add(sload(balanceSlot), 1)\n // Revert if `to` is the zero address, or if the account balance overflows.\n if iszero(mul(to, and(balanceSlotPacked, _MAX_ACCOUNT_BALANCE))) {\n // `TransferToZeroAddress()`, `AccountBalanceOverflow()`.\n mstore(shl(2, iszero(to)), 0xea553b3401336cea)\n revert(0x1c, 0x04)\n }\n sstore(balanceSlot, balanceSlotPacked)\n }\n // Emit the {Transfer} event.\n log4(codesize(), 0x00, _TRANSFER_EVENT_SIGNATURE, 0, to, id)\n }\n _afterTokenTransfer(address(0), to, id);\n }\n\n /// @dev Mints token `id` to `to`, and updates the extra data for token `id` to `value`.\n /// Does NOT check if token `id` already exists (assumes `id` is auto-incrementing).\n ///\n /// Requirements:\n ///\n /// - `to` cannot be the zero address.\n ///\n /// Emits a {Transfer} event.\n function _mintAndSetExtraDataUnchecked(address to, uint256 id, uint96 value) internal virtual {\n _beforeTokenTransfer(address(0), to, id);\n /// @solidity memory-safe-assembly\n assembly {\n // Clear the upper 96 bits.\n to := shr(96, shl(96, to))\n // Update with the owner and extra data.\n mstore(0x00, id)\n mstore(0x1c, _ERC721_MASTER_SLOT_SEED)\n sstore(add(id, add(id, keccak256(0x00, 0x20))), or(shl(160, value), to))\n // Increment the balance of the owner.\n {\n mstore(0x00, to)\n let balanceSlot := keccak256(0x0c, 0x1c)\n let balanceSlotPacked := add(sload(balanceSlot), 1)\n // Revert if `to` is the zero address, or if the account balance overflows.\n if iszero(mul(to, and(balanceSlotPacked, _MAX_ACCOUNT_BALANCE))) {\n // `TransferToZeroAddress()`, `AccountBalanceOverflow()`.\n mstore(shl(2, iszero(to)), 0xea553b3401336cea)\n revert(0x1c, 0x04)\n }\n sstore(balanceSlot, balanceSlotPacked)\n }\n // Emit the {Transfer} event.\n log4(codesize(), 0x00, _TRANSFER_EVENT_SIGNATURE, 0, to, id)\n }\n _afterTokenTransfer(address(0), to, id);\n }\n\n /// @dev Equivalent to `_safeMint(to, id, \"\")`.\n function _safeMint(address to, uint256 id) internal virtual {\n _safeMint(to, id, \"\");\n }\n\n /// @dev Mints token `id` to `to`.\n ///\n /// Requirements:\n ///\n /// - Token `id` must not exist.\n /// - `to` cannot be the zero address.\n /// - If `to` refers to a smart contract, it must implement\n /// {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n ///\n /// Emits a {Transfer} event.\n function _safeMint(address to, uint256 id, bytes memory data) internal virtual {\n _mint(to, id);\n if (_hasCode(to)) _checkOnERC721Received(address(0), to, id, data);\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* INTERNAL BURN FUNCTIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Equivalent to `_burn(address(0), id)`.\n function _burn(uint256 id) internal virtual {\n _burn(address(0), id);\n }\n\n /// @dev Destroys token `id`, using `by`.\n ///\n /// Requirements:\n ///\n /// - Token `id` must exist.\n /// - If `by` is not the zero address,\n /// it must be the owner of the token, or be approved to manage the token.\n ///\n /// Emits a {Transfer} event.\n function _burn(address by, uint256 id) internal virtual {\n address owner = ownerOf(id);\n _beforeTokenTransfer(owner, address(0), id);\n /// @solidity memory-safe-assembly\n assembly {\n // Clear the upper 96 bits.\n by := shr(96, shl(96, by))\n // Load the ownership data.\n mstore(0x00, id)\n mstore(0x1c, or(_ERC721_MASTER_SLOT_SEED, by))\n let ownershipSlot := add(id, add(id, keccak256(0x00, 0x20)))\n let ownershipPacked := sload(ownershipSlot)\n // Reload the owner in case it is changed in `_beforeTokenTransfer`.\n owner := shr(96, shl(96, ownershipPacked))\n // Revert if the token does not exist.\n if iszero(owner) {\n mstore(0x00, 0xceea21b6) // `TokenDoesNotExist()`.\n revert(0x1c, 0x04)\n }\n // Load and check the token approval.\n {\n mstore(0x00, owner)\n let approvedAddress := sload(add(1, ownershipSlot))\n // If `by` is not the zero address, do the authorization check.\n // Revert if the `by` is not the owner, nor approved.\n if iszero(or(iszero(by), or(eq(by, owner), eq(by, approvedAddress)))) {\n if iszero(sload(keccak256(0x0c, 0x30))) {\n mstore(0x00, 0x4b6e7f18) // `NotOwnerNorApproved()`.\n revert(0x1c, 0x04)\n }\n }\n // Delete the approved address if any.\n if approvedAddress { sstore(add(1, ownershipSlot), 0) }\n }\n // Clear the owner.\n sstore(ownershipSlot, xor(ownershipPacked, owner))\n // Decrement the balance of `owner`.\n {\n let balanceSlot := keccak256(0x0c, 0x1c)\n sstore(balanceSlot, sub(sload(balanceSlot), 1))\n }\n // Emit the {Transfer} event.\n log4(codesize(), 0x00, _TRANSFER_EVENT_SIGNATURE, owner, 0, id)\n }\n _afterTokenTransfer(owner, address(0), id);\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* INTERNAL APPROVAL FUNCTIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Returns whether `account` is the owner of token `id`, or is approved to manage it.\n ///\n /// Requirements:\n /// - Token `id` must exist.\n function _isApprovedOrOwner(address account, uint256 id)\n internal\n view\n virtual\n returns (bool result)\n {\n /// @solidity memory-safe-assembly\n assembly {\n result := 1\n // Clear the upper 96 bits.\n account := shr(96, shl(96, account))\n // Load the ownership data.\n mstore(0x00, id)\n mstore(0x1c, or(_ERC721_MASTER_SLOT_SEED, account))\n let ownershipSlot := add(id, add(id, keccak256(0x00, 0x20)))\n let owner := shr(96, shl(96, sload(ownershipSlot)))\n // Revert if the token does not exist.\n if iszero(owner) {\n mstore(0x00, 0xceea21b6) // `TokenDoesNotExist()`.\n revert(0x1c, 0x04)\n }\n // Check if `account` is the `owner`.\n if iszero(eq(account, owner)) {\n mstore(0x00, owner)\n // Check if `account` is approved to manage the token.\n if iszero(sload(keccak256(0x0c, 0x30))) {\n result := eq(account, sload(add(1, ownershipSlot)))\n }\n }\n }\n }\n\n /// @dev Returns the account approved to manage token `id`.\n /// Returns the zero address instead of reverting if the token does not exist.\n function _getApproved(uint256 id) internal view virtual returns (address result) {\n /// @solidity memory-safe-assembly\n assembly {\n mstore(0x00, id)\n mstore(0x1c, _ERC721_MASTER_SLOT_SEED)\n result := sload(add(1, add(id, add(id, keccak256(0x00, 0x20)))))\n }\n }\n\n /// @dev Equivalent to `_approve(address(0), account, id)`.\n function _approve(address account, uint256 id) internal virtual {\n _approve(address(0), account, id);\n }\n\n /// @dev Sets `account` as the approved account to manage token `id`, using `by`.\n ///\n /// Requirements:\n /// - Token `id` must exist.\n /// - If `by` is not the zero address, `by` must be the owner\n /// or an approved operator for the token owner.\n ///\n /// Emits a {Approval} event.\n function _approve(address by, address account, uint256 id) internal virtual {\n assembly {\n // Clear the upper 96 bits.\n let bitmaskAddress := shr(96, not(0))\n account := and(bitmaskAddress, account)\n by := and(bitmaskAddress, by)\n // Load the owner of the token.\n mstore(0x00, id)\n mstore(0x1c, or(_ERC721_MASTER_SLOT_SEED, by))\n let ownershipSlot := add(id, add(id, keccak256(0x00, 0x20)))\n let owner := and(bitmaskAddress, sload(ownershipSlot))\n // Revert if the token does not exist.\n if iszero(owner) {\n mstore(0x00, 0xceea21b6) // `TokenDoesNotExist()`.\n revert(0x1c, 0x04)\n }\n // If `by` is not the zero address, do the authorization check.\n // Revert if `by` is not the owner, nor approved.\n if iszero(or(iszero(by), eq(by, owner))) {\n mstore(0x00, owner)\n if iszero(sload(keccak256(0x0c, 0x30))) {\n mstore(0x00, 0x4b6e7f18) // `NotOwnerNorApproved()`.\n revert(0x1c, 0x04)\n }\n }\n // Sets `account` as the approved account to manage `id`.\n sstore(add(1, ownershipSlot), account)\n // Emit the {Approval} event.\n log4(codesize(), 0x00, _APPROVAL_EVENT_SIGNATURE, owner, account, id)\n }\n }\n\n /// @dev Approve or remove the `operator` as an operator for `by`,\n /// without authorization checks.\n ///\n /// Emits an {ApprovalForAll} event.\n function _setApprovalForAll(address by, address operator, bool isApproved) internal virtual {\n /// @solidity memory-safe-assembly\n assembly {\n // Clear the upper 96 bits.\n by := shr(96, shl(96, by))\n operator := shr(96, shl(96, operator))\n // Convert to 0 or 1.\n isApproved := iszero(iszero(isApproved))\n // Update the `isApproved` for (`by`, `operator`).\n mstore(0x1c, or(_ERC721_MASTER_SLOT_SEED, operator))\n mstore(0x00, by)\n sstore(keccak256(0x0c, 0x30), isApproved)\n // Emit the {ApprovalForAll} event.\n mstore(0x00, isApproved)\n log3(0x00, 0x20, _APPROVAL_FOR_ALL_EVENT_SIGNATURE, by, operator)\n }\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* INTERNAL TRANSFER FUNCTIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Equivalent to `_transfer(address(0), from, to, id)`.\n function _transfer(address from, address to, uint256 id) internal virtual {\n _transfer(address(0), from, to, id);\n }\n\n /// @dev Transfers token `id` from `from` to `to`.\n ///\n /// Requirements:\n ///\n /// - Token `id` must exist.\n /// - `from` must be the owner of the token.\n /// - `to` cannot be the zero address.\n /// - If `by` is not the zero address,\n /// it must be the owner of the token, or be approved to manage the token.\n ///\n /// Emits a {Transfer} event.\n function _transfer(address by, address from, address to, uint256 id) internal virtual {\n _beforeTokenTransfer(from, to, id);\n /// @solidity memory-safe-assembly\n assembly {\n // Clear the upper 96 bits.\n let bitmaskAddress := shr(96, not(0))\n from := and(bitmaskAddress, from)\n to := and(bitmaskAddress, to)\n by := and(bitmaskAddress, by)\n // Load the ownership data.\n mstore(0x00, id)\n mstore(0x1c, or(_ERC721_MASTER_SLOT_SEED, by))\n let ownershipSlot := add(id, add(id, keccak256(0x00, 0x20)))\n let ownershipPacked := sload(ownershipSlot)\n let owner := and(bitmaskAddress, ownershipPacked)\n // Revert if the token does not exist, or if `from` is not the owner.\n if iszero(mul(owner, eq(owner, from))) {\n // `TokenDoesNotExist()`, `TransferFromIncorrectOwner()`.\n mstore(shl(2, iszero(owner)), 0xceea21b6a1148100)\n revert(0x1c, 0x04)\n }\n // Load, check, and update the token approval.\n {\n mstore(0x00, from)\n let approvedAddress := sload(add(1, ownershipSlot))\n // If `by` is not the zero address, do the authorization check.\n // Revert if the `by` is not the owner, nor approved.\n if iszero(or(iszero(by), or(eq(by, from), eq(by, approvedAddress)))) {\n if iszero(sload(keccak256(0x0c, 0x30))) {\n mstore(0x00, 0x4b6e7f18) // `NotOwnerNorApproved()`.\n revert(0x1c, 0x04)\n }\n }\n // Delete the approved address if any.\n if approvedAddress { sstore(add(1, ownershipSlot), 0) }\n }\n // Update with the new owner.\n sstore(ownershipSlot, xor(ownershipPacked, xor(from, to)))\n // Decrement the balance of `from`.\n {\n let fromBalanceSlot := keccak256(0x0c, 0x1c)\n sstore(fromBalanceSlot, sub(sload(fromBalanceSlot), 1))\n }\n // Increment the balance of `to`.\n {\n mstore(0x00, to)\n let toBalanceSlot := keccak256(0x0c, 0x1c)\n let toBalanceSlotPacked := add(sload(toBalanceSlot), 1)\n // Revert if `to` is the zero address, or if the account balance overflows.\n if iszero(mul(to, and(toBalanceSlotPacked, _MAX_ACCOUNT_BALANCE))) {\n // `TransferToZeroAddress()`, `AccountBalanceOverflow()`.\n mstore(shl(2, iszero(to)), 0xea553b3401336cea)\n revert(0x1c, 0x04)\n }\n sstore(toBalanceSlot, toBalanceSlotPacked)\n }\n // Emit the {Transfer} event.\n log4(codesize(), 0x00, _TRANSFER_EVENT_SIGNATURE, from, to, id)\n }\n _afterTokenTransfer(from, to, id);\n }\n\n /// @dev Equivalent to `_safeTransfer(from, to, id, \"\")`.\n function _safeTransfer(address from, address to, uint256 id) internal virtual {\n _safeTransfer(from, to, id, \"\");\n }\n\n /// @dev Transfers token `id` from `from` to `to`.\n ///\n /// Requirements:\n ///\n /// - Token `id` must exist.\n /// - `from` must be the owner of the token.\n /// - `to` cannot be the zero address.\n /// - The caller must be the owner of the token, or be approved to manage the token.\n /// - If `to` refers to a smart contract, it must implement\n /// {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n ///\n /// Emits a {Transfer} event.\n function _safeTransfer(address from, address to, uint256 id, bytes memory data)\n internal\n virtual\n {\n _transfer(address(0), from, to, id);\n if (_hasCode(to)) _checkOnERC721Received(from, to, id, data);\n }\n\n /// @dev Equivalent to `_safeTransfer(by, from, to, id, \"\")`.\n function _safeTransfer(address by, address from, address to, uint256 id) internal virtual {\n _safeTransfer(by, from, to, id, \"\");\n }\n\n /// @dev Transfers token `id` from `from` to `to`.\n ///\n /// Requirements:\n ///\n /// - Token `id` must exist.\n /// - `from` must be the owner of the token.\n /// - `to` cannot be the zero address.\n /// - If `by` is not the zero address,\n /// it must be the owner of the token, or be approved to manage the token.\n /// - If `to` refers to a smart contract, it must implement\n /// {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n ///\n /// Emits a {Transfer} event.\n function _safeTransfer(address by, address from, address to, uint256 id, bytes memory data)\n internal\n virtual\n {\n _transfer(by, from, to, id);\n if (_hasCode(to)) _checkOnERC721Received(from, to, id, data);\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* HOOKS FOR OVERRIDING */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Hook that is called before any token transfers, including minting and burning.\n function _beforeTokenTransfer(address from, address to, uint256 id) internal virtual {}\n\n /// @dev Hook that is called after any token transfers, including minting and burning.\n function _afterTokenTransfer(address from, address to, uint256 id) internal virtual {}\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* PRIVATE HELPERS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Returns if `a` has bytecode of non-zero length.\n function _hasCode(address a) private view returns (bool result) {\n /// @solidity memory-safe-assembly\n assembly {\n result := extcodesize(a) // Can handle dirty upper bits.\n }\n }\n\n /// @dev Perform a call to invoke {IERC721Receiver-onERC721Received} on `to`.\n /// Reverts if the target does not support the function correctly.\n function _checkOnERC721Received(address from, address to, uint256 id, bytes memory data)\n private\n {\n /// @solidity memory-safe-assembly\n assembly {\n // Prepare the calldata.\n let m := mload(0x40)\n let onERC721ReceivedSelector := 0x150b7a02\n mstore(m, onERC721ReceivedSelector)\n mstore(add(m, 0x20), caller()) // The `operator`, which is always `msg.sender`.\n mstore(add(m, 0x40), shr(96, shl(96, from)))\n mstore(add(m, 0x60), id)\n mstore(add(m, 0x80), 0x80)\n let n := mload(data)\n mstore(add(m, 0xa0), n)\n if n { pop(staticcall(gas(), 4, add(data, 0x20), n, add(m, 0xc0), n)) }\n // Revert if the call reverts.\n if iszero(call(gas(), to, 0, add(m, 0x1c), add(n, 0xa4), m, 0x20)) {\n if returndatasize() {\n // Bubble up the revert if the call reverts.\n returndatacopy(m, 0x00, returndatasize())\n revert(m, returndatasize())\n }\n }\n // Load the returndata and compare it.\n if iszero(eq(mload(m), shl(224, onERC721ReceivedSelector))) {\n mstore(0x00, 0xd1a57ed6) // `TransferToNonERC721ReceiverImplementer()`.\n revert(0x1c, 0x04)\n }\n }\n }\n}\n"},"solady/src/utils/Base64.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Library to encode strings in Base64.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/Base64.sol)\n/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/Base64.sol)\n/// @author Modified from (https://github.com/Brechtpd/base64/blob/main/base64.sol) by Brecht Devos - .\nlibrary Base64 {\n /// @dev Encodes `data` using the base64 encoding described in RFC 4648.\n /// See: https://datatracker.ietf.org/doc/html/rfc4648\n /// @param fileSafe Whether to replace '+' with '-' and '/' with '_'.\n /// @param noPadding Whether to strip away the padding.\n function encode(bytes memory data, bool fileSafe, bool noPadding)\n internal\n pure\n returns (string memory result)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let dataLength := mload(data)\n\n if dataLength {\n // Multiply by 4/3 rounded up.\n // The `shl(2, ...)` is equivalent to multiplying by 4.\n let encodedLength := shl(2, div(add(dataLength, 2), 3))\n\n // Set `result` to point to the start of the free memory.\n result := mload(0x40)\n\n // Store the table into the scratch space.\n // Offsetted by -1 byte so that the `mload` will load the character.\n // We will rewrite the free memory pointer at `0x40` later with\n // the allocated size.\n // The magic constant 0x0670 will turn \"-_\" into \"+/\".\n mstore(0x1f, \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdef\")\n mstore(0x3f, xor(\"ghijklmnopqrstuvwxyz0123456789-_\", mul(iszero(fileSafe), 0x0670)))\n\n // Skip the first slot, which stores the length.\n let ptr := add(result, 0x20)\n let end := add(ptr, encodedLength)\n\n let dataEnd := add(add(0x20, data), dataLength)\n let dataEndValue := mload(dataEnd) // Cache the value at the `dataEnd` slot.\n mstore(dataEnd, 0x00) // Zeroize the `dataEnd` slot to clear dirty bits.\n\n // Run over the input, 3 bytes at a time.\n for {} 1 {} {\n data := add(data, 3) // Advance 3 bytes.\n let input := mload(data)\n\n // Write 4 bytes. Optimized for fewer stack operations.\n mstore8(0, mload(and(shr(18, input), 0x3F)))\n mstore8(1, mload(and(shr(12, input), 0x3F)))\n mstore8(2, mload(and(shr(6, input), 0x3F)))\n mstore8(3, mload(and(input, 0x3F)))\n mstore(ptr, mload(0x00))\n\n ptr := add(ptr, 4) // Advance 4 bytes.\n if iszero(lt(ptr, end)) { break }\n }\n mstore(dataEnd, dataEndValue) // Restore the cached value at `dataEnd`.\n mstore(0x40, add(end, 0x20)) // Allocate the memory.\n // Equivalent to `o = [0, 2, 1][dataLength % 3]`.\n let o := div(2, mod(dataLength, 3))\n // Offset `ptr` and pad with '='. We can simply write over the end.\n mstore(sub(ptr, o), shl(240, 0x3d3d))\n // Set `o` to zero if there is padding.\n o := mul(iszero(iszero(noPadding)), o)\n mstore(sub(ptr, o), 0) // Zeroize the slot after the string.\n mstore(result, sub(encodedLength, o)) // Store the length.\n }\n }\n }\n\n /// @dev Encodes `data` using the base64 encoding described in RFC 4648.\n /// Equivalent to `encode(data, false, false)`.\n function encode(bytes memory data) internal pure returns (string memory result) {\n result = encode(data, false, false);\n }\n\n /// @dev Encodes `data` using the base64 encoding described in RFC 4648.\n /// Equivalent to `encode(data, fileSafe, false)`.\n function encode(bytes memory data, bool fileSafe)\n internal\n pure\n returns (string memory result)\n {\n result = encode(data, fileSafe, false);\n }\n\n /// @dev Decodes base64 encoded `data`.\n ///\n /// Supports:\n /// - RFC 4648 (both standard and file-safe mode).\n /// - RFC 3501 (63: ',').\n ///\n /// Does not support:\n /// - Line breaks.\n ///\n /// Note: For performance reasons,\n /// this function will NOT revert on invalid `data` inputs.\n /// Outputs for invalid inputs will simply be undefined behaviour.\n /// It is the user's responsibility to ensure that the `data`\n /// is a valid base64 encoded string.\n function decode(string memory data) internal pure returns (bytes memory result) {\n /// @solidity memory-safe-assembly\n assembly {\n let dataLength := mload(data)\n\n if dataLength {\n let decodedLength := mul(shr(2, dataLength), 3)\n\n for {} 1 {} {\n // If padded.\n if iszero(and(dataLength, 3)) {\n let t := xor(mload(add(data, dataLength)), 0x3d3d)\n // forgefmt: disable-next-item\n decodedLength := sub(\n decodedLength,\n add(iszero(byte(30, t)), iszero(byte(31, t)))\n )\n break\n }\n // If non-padded.\n decodedLength := add(decodedLength, sub(and(dataLength, 3), 1))\n break\n }\n result := mload(0x40)\n\n // Write the length of the bytes.\n mstore(result, decodedLength)\n\n // Skip the first slot, which stores the length.\n let ptr := add(result, 0x20)\n let end := add(ptr, decodedLength)\n\n // Load the table into the scratch space.\n // Constants are optimized for smaller bytecode with zero gas overhead.\n // `m` also doubles as the mask of the upper 6 bits.\n let m := 0xfc000000fc00686c7074787c8084888c9094989ca0a4a8acb0b4b8bcc0c4c8cc\n mstore(0x5b, m)\n mstore(0x3b, 0x04080c1014181c2024282c3034383c4044484c5054585c6064)\n mstore(0x1a, 0xf8fcf800fcd0d4d8dce0e4e8ecf0f4)\n\n for {} 1 {} {\n // Read 4 bytes.\n data := add(data, 4)\n let input := mload(data)\n\n // Write 3 bytes.\n // forgefmt: disable-next-item\n mstore(ptr, or(\n and(m, mload(byte(28, input))),\n shr(6, or(\n and(m, mload(byte(29, input))),\n shr(6, or(\n and(m, mload(byte(30, input))),\n shr(6, mload(byte(31, input)))\n ))\n ))\n ))\n ptr := add(ptr, 3)\n if iszero(lt(ptr, end)) { break }\n }\n mstore(0x40, add(end, 0x20)) // Allocate the memory.\n mstore(end, 0) // Zeroize the slot after the bytes.\n mstore(0x60, 0) // Restore the zero slot.\n }\n }\n }\n}\n"},"solady/src/utils/LibString.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Library for converting numbers into strings and other string operations.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibString.sol)\n/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/LibString.sol)\n///\n/// @dev Note:\n/// For performance and bytecode compactness, most of the string operations are restricted to\n/// byte strings (7-bit ASCII), except where otherwise specified.\n/// Usage of byte string operations on charsets with runes spanning two or more bytes\n/// can lead to undefined behavior.\nlibrary LibString {\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* CUSTOM ERRORS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev The length of the output is too small to contain all the hex digits.\n error HexLengthInsufficient();\n\n /// @dev The length of the string is more than 32 bytes.\n error TooBigForSmallString();\n\n /// @dev The input string must be a 7-bit ASCII.\n error StringNot7BitASCII();\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* CONSTANTS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev The constant returned when the `search` is not found in the string.\n uint256 internal constant NOT_FOUND = type(uint256).max;\n\n /// @dev Lookup for '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.\n uint128 internal constant ALPHANUMERIC_7_BIT_ASCII = 0x7fffffe07fffffe03ff000000000000;\n\n /// @dev Lookup for 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.\n uint128 internal constant LETTERS_7_BIT_ASCII = 0x7fffffe07fffffe0000000000000000;\n\n /// @dev Lookup for 'abcdefghijklmnopqrstuvwxyz'.\n uint128 internal constant LOWERCASE_7_BIT_ASCII = 0x7fffffe000000000000000000000000;\n\n /// @dev Lookup for 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.\n uint128 internal constant UPPERCASE_7_BIT_ASCII = 0x7fffffe0000000000000000;\n\n /// @dev Lookup for '0123456789'.\n uint128 internal constant DIGITS_7_BIT_ASCII = 0x3ff000000000000;\n\n /// @dev Lookup for '0123456789abcdefABCDEF'.\n uint128 internal constant HEXDIGITS_7_BIT_ASCII = 0x7e0000007e03ff000000000000;\n\n /// @dev Lookup for '01234567'.\n uint128 internal constant OCTDIGITS_7_BIT_ASCII = 0xff000000000000;\n\n /// @dev Lookup for '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!\"#$%&\\'()*+,-./:;<=>?@[\\\\]^_`{|}~ \\t\\n\\r\\x0b\\x0c'.\n uint128 internal constant PRINTABLE_7_BIT_ASCII = 0x7fffffffffffffffffffffff00003e00;\n\n /// @dev Lookup for '!\"#$%&\\'()*+,-./:;<=>?@[\\\\]^_`{|}~'.\n uint128 internal constant PUNCTUATION_7_BIT_ASCII = 0x78000001f8000001fc00fffe00000000;\n\n /// @dev Lookup for ' \\t\\n\\r\\x0b\\x0c'.\n uint128 internal constant WHITESPACE_7_BIT_ASCII = 0x100003e00;\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* DECIMAL OPERATIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Returns the base 10 decimal representation of `value`.\n function toString(uint256 value) internal pure returns (string memory str) {\n /// @solidity memory-safe-assembly\n assembly {\n // The maximum value of a uint256 contains 78 digits (1 byte per digit), but\n // we allocate 0xa0 bytes to keep the free memory pointer 32-byte word aligned.\n // We will need 1 word for the trailing zeros padding, 1 word for the length,\n // and 3 words for a maximum of 78 digits.\n str := add(mload(0x40), 0x80)\n mstore(0x40, add(str, 0x20)) // Allocate the memory.\n mstore(str, 0) // Zeroize the slot after the string.\n\n let end := str // Cache the end of the memory to calculate the length later.\n let w := not(0) // Tsk.\n // We write the string from rightmost digit to leftmost digit.\n // The following is essentially a do-while loop that also handles the zero case.\n for { let temp := value } 1 {} {\n str := add(str, w) // `sub(str, 1)`.\n // Store the character to the pointer.\n // The ASCII index of the '0' character is 48.\n mstore8(str, add(48, mod(temp, 10)))\n temp := div(temp, 10) // Keep dividing `temp` until zero.\n if iszero(temp) { break }\n }\n let length := sub(end, str)\n str := sub(str, 0x20) // Move the pointer 32 bytes back to make room for the length.\n mstore(str, length) // Store the length.\n }\n }\n\n /// @dev Returns the base 10 decimal representation of `value`.\n function toString(int256 value) internal pure returns (string memory str) {\n if (value >= 0) return toString(uint256(value));\n unchecked {\n str = toString(~uint256(value) + 1);\n }\n /// @solidity memory-safe-assembly\n assembly {\n // We still have some spare memory space on the left,\n // as we have allocated 3 words (96 bytes) for up to 78 digits.\n let length := mload(str) // Load the string length.\n mstore(str, 0x2d) // Store the '-' character.\n str := sub(str, 1) // Move back the string pointer by a byte.\n mstore(str, add(length, 1)) // Update the string length.\n }\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* HEXADECIMAL OPERATIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Returns the hexadecimal representation of `value`,\n /// left-padded to an input length of `length` bytes.\n /// The output is prefixed with \"0x\" encoded using 2 hexadecimal digits per byte,\n /// giving a total length of `length * 2 + 2` bytes.\n /// Reverts if `length` is too small for the output to contain all the digits.\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory str) {\n str = toHexStringNoPrefix(value, length);\n /// @solidity memory-safe-assembly\n assembly {\n let strLength := add(mload(str), 2) // Compute the length.\n mstore(str, 0x3078) // Store the \"0x\" prefix.\n str := sub(str, 2) // Move the pointer.\n mstore(str, strLength) // Store the length.\n }\n }\n\n /// @dev Returns the hexadecimal representation of `value`,\n /// left-padded to an input length of `length` bytes.\n /// The output is prefixed with \"0x\" encoded using 2 hexadecimal digits per byte,\n /// giving a total length of `length * 2` bytes.\n /// Reverts if `length` is too small for the output to contain all the digits.\n function toHexStringNoPrefix(uint256 value, uint256 length)\n internal\n pure\n returns (string memory str)\n {\n /// @solidity memory-safe-assembly\n assembly {\n // We need 0x20 bytes for the trailing zeros padding, `length * 2` bytes\n // for the digits, 0x02 bytes for the prefix, and 0x20 bytes for the length.\n // We add 0x20 to the total and round down to a multiple of 0x20.\n // (0x20 + 0x20 + 0x02 + 0x20) = 0x62.\n str := add(mload(0x40), and(add(shl(1, length), 0x42), not(0x1f)))\n mstore(0x40, add(str, 0x20)) // Allocate the memory.\n mstore(str, 0) // Zeroize the slot after the string.\n\n let end := str // Cache the end to calculate the length later.\n // Store \"0123456789abcdef\" in scratch space.\n mstore(0x0f, 0x30313233343536373839616263646566)\n\n let start := sub(str, add(length, length))\n let w := not(1) // Tsk.\n let temp := value\n // We write the string from rightmost digit to leftmost digit.\n // The following is essentially a do-while loop that also handles the zero case.\n for {} 1 {} {\n str := add(str, w) // `sub(str, 2)`.\n mstore8(add(str, 1), mload(and(temp, 15)))\n mstore8(str, mload(and(shr(4, temp), 15)))\n temp := shr(8, temp)\n if iszero(xor(str, start)) { break }\n }\n if temp {\n mstore(0x00, 0x2194895a) // `HexLengthInsufficient()`.\n revert(0x1c, 0x04)\n }\n let strLength := sub(end, str)\n str := sub(str, 0x20)\n mstore(str, strLength) // Store the length.\n }\n }\n\n /// @dev Returns the hexadecimal representation of `value`.\n /// The output is prefixed with \"0x\" and encoded using 2 hexadecimal digits per byte.\n /// As address are 20 bytes long, the output will left-padded to have\n /// a length of `20 * 2 + 2` bytes.\n function toHexString(uint256 value) internal pure returns (string memory str) {\n str = toHexStringNoPrefix(value);\n /// @solidity memory-safe-assembly\n assembly {\n let strLength := add(mload(str), 2) // Compute the length.\n mstore(str, 0x3078) // Store the \"0x\" prefix.\n str := sub(str, 2) // Move the pointer.\n mstore(str, strLength) // Store the length.\n }\n }\n\n /// @dev Returns the hexadecimal representation of `value`.\n /// The output is prefixed with \"0x\".\n /// The output excludes leading \"0\" from the `toHexString` output.\n /// `0x00: \"0x0\", 0x01: \"0x1\", 0x12: \"0x12\", 0x123: \"0x123\"`.\n function toMinimalHexString(uint256 value) internal pure returns (string memory str) {\n str = toHexStringNoPrefix(value);\n /// @solidity memory-safe-assembly\n assembly {\n let o := eq(byte(0, mload(add(str, 0x20))), 0x30) // Whether leading zero is present.\n let strLength := add(mload(str), 2) // Compute the length.\n mstore(add(str, o), 0x3078) // Store the \"0x\" prefix, accounting for leading zero.\n str := sub(add(str, o), 2) // Move the pointer, accounting for leading zero.\n mstore(str, sub(strLength, o)) // Store the length, accounting for leading zero.\n }\n }\n\n /// @dev Returns the hexadecimal representation of `value`.\n /// The output excludes leading \"0\" from the `toHexStringNoPrefix` output.\n /// `0x00: \"0\", 0x01: \"1\", 0x12: \"12\", 0x123: \"123\"`.\n function toMinimalHexStringNoPrefix(uint256 value) internal pure returns (string memory str) {\n str = toHexStringNoPrefix(value);\n /// @solidity memory-safe-assembly\n assembly {\n let o := eq(byte(0, mload(add(str, 0x20))), 0x30) // Whether leading zero is present.\n let strLength := mload(str) // Get the length.\n str := add(str, o) // Move the pointer, accounting for leading zero.\n mstore(str, sub(strLength, o)) // Store the length, accounting for leading zero.\n }\n }\n\n /// @dev Returns the hexadecimal representation of `value`.\n /// The output is encoded using 2 hexadecimal digits per byte.\n /// As address are 20 bytes long, the output will left-padded to have\n /// a length of `20 * 2` bytes.\n function toHexStringNoPrefix(uint256 value) internal pure returns (string memory str) {\n /// @solidity memory-safe-assembly\n assembly {\n // We need 0x20 bytes for the trailing zeros padding, 0x20 bytes for the length,\n // 0x02 bytes for the prefix, and 0x40 bytes for the digits.\n // The next multiple of 0x20 above (0x20 + 0x20 + 0x02 + 0x40) is 0xa0.\n str := add(mload(0x40), 0x80)\n mstore(0x40, add(str, 0x20)) // Allocate the memory.\n mstore(str, 0) // Zeroize the slot after the string.\n\n let end := str // Cache the end to calculate the length later.\n mstore(0x0f, 0x30313233343536373839616263646566) // Store the \"0123456789abcdef\" lookup.\n\n let w := not(1) // Tsk.\n // We write the string from rightmost digit to leftmost digit.\n // The following is essentially a do-while loop that also handles the zero case.\n for { let temp := value } 1 {} {\n str := add(str, w) // `sub(str, 2)`.\n mstore8(add(str, 1), mload(and(temp, 15)))\n mstore8(str, mload(and(shr(4, temp), 15)))\n temp := shr(8, temp)\n if iszero(temp) { break }\n }\n let strLength := sub(end, str)\n str := sub(str, 0x20)\n mstore(str, strLength) // Store the length.\n }\n }\n\n /// @dev Returns the hexadecimal representation of `value`.\n /// The output is prefixed with \"0x\", encoded using 2 hexadecimal digits per byte,\n /// and the alphabets are capitalized conditionally according to\n /// https://eips.ethereum.org/EIPS/eip-55\n function toHexStringChecksummed(address value) internal pure returns (string memory str) {\n str = toHexString(value);\n /// @solidity memory-safe-assembly\n assembly {\n let mask := shl(6, div(not(0), 255)) // `0b010000000100000000 ...`\n let o := add(str, 0x22)\n let hashed := and(keccak256(o, 40), mul(34, mask)) // `0b10001000 ... `\n let t := shl(240, 136) // `0b10001000 << 240`\n for { let i := 0 } 1 {} {\n mstore(add(i, i), mul(t, byte(i, hashed)))\n i := add(i, 1)\n if eq(i, 20) { break }\n }\n mstore(o, xor(mload(o), shr(1, and(mload(0x00), and(mload(o), mask)))))\n o := add(o, 0x20)\n mstore(o, xor(mload(o), shr(1, and(mload(0x20), and(mload(o), mask)))))\n }\n }\n\n /// @dev Returns the hexadecimal representation of `value`.\n /// The output is prefixed with \"0x\" and encoded using 2 hexadecimal digits per byte.\n function toHexString(address value) internal pure returns (string memory str) {\n str = toHexStringNoPrefix(value);\n /// @solidity memory-safe-assembly\n assembly {\n let strLength := add(mload(str), 2) // Compute the length.\n mstore(str, 0x3078) // Store the \"0x\" prefix.\n str := sub(str, 2) // Move the pointer.\n mstore(str, strLength) // Store the length.\n }\n }\n\n /// @dev Returns the hexadecimal representation of `value`.\n /// The output is encoded using 2 hexadecimal digits per byte.\n function toHexStringNoPrefix(address value) internal pure returns (string memory str) {\n /// @solidity memory-safe-assembly\n assembly {\n str := mload(0x40)\n // Allocate the memory.\n // We need 0x20 bytes for the trailing zeros padding, 0x20 bytes for the length,\n // 0x02 bytes for the prefix, and 0x28 bytes for the digits.\n // The next multiple of 0x20 above (0x20 + 0x20 + 0x02 + 0x28) is 0x80.\n mstore(0x40, add(str, 0x80))\n mstore(0x0f, 0x30313233343536373839616263646566) // Store the \"0123456789abcdef\" lookup.\n\n str := add(str, 2)\n mstore(str, 40) // Store the length.\n let o := add(str, 0x20)\n mstore(add(o, 40), 0) // Zeroize the slot after the string.\n value := shl(96, value)\n // We write the string from rightmost digit to leftmost digit.\n // The following is essentially a do-while loop that also handles the zero case.\n for { let i := 0 } 1 {} {\n let p := add(o, add(i, i))\n let temp := byte(i, value)\n mstore8(add(p, 1), mload(and(temp, 15)))\n mstore8(p, mload(shr(4, temp)))\n i := add(i, 1)\n if eq(i, 20) { break }\n }\n }\n }\n\n /// @dev Returns the hex encoded string from the raw bytes.\n /// The output is encoded using 2 hexadecimal digits per byte.\n function toHexString(bytes memory raw) internal pure returns (string memory str) {\n str = toHexStringNoPrefix(raw);\n /// @solidity memory-safe-assembly\n assembly {\n let strLength := add(mload(str), 2) // Compute the length.\n mstore(str, 0x3078) // Store the \"0x\" prefix.\n str := sub(str, 2) // Move the pointer.\n mstore(str, strLength) // Store the length.\n }\n }\n\n /// @dev Returns the hex encoded string from the raw bytes.\n /// The output is encoded using 2 hexadecimal digits per byte.\n function toHexStringNoPrefix(bytes memory raw) internal pure returns (string memory str) {\n /// @solidity memory-safe-assembly\n assembly {\n let length := mload(raw)\n str := add(mload(0x40), 2) // Skip 2 bytes for the optional prefix.\n mstore(str, add(length, length)) // Store the length of the output.\n\n mstore(0x0f, 0x30313233343536373839616263646566) // Store the \"0123456789abcdef\" lookup.\n let o := add(str, 0x20)\n let end := add(raw, length)\n for {} iszero(eq(raw, end)) {} {\n raw := add(raw, 1)\n mstore8(add(o, 1), mload(and(mload(raw), 15)))\n mstore8(o, mload(and(shr(4, mload(raw)), 15)))\n o := add(o, 2)\n }\n mstore(o, 0) // Zeroize the slot after the string.\n mstore(0x40, add(o, 0x20)) // Allocate the memory.\n }\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* RUNE STRING OPERATIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n /// @dev Returns the number of UTF characters in the string.\n function runeCount(string memory s) internal pure returns (uint256 result) {\n /// @solidity memory-safe-assembly\n assembly {\n if mload(s) {\n mstore(0x00, div(not(0), 255))\n mstore(0x20, 0x0202020202020202020202020202020202020202020202020303030304040506)\n let o := add(s, 0x20)\n let end := add(o, mload(s))\n for { result := 1 } 1 { result := add(result, 1) } {\n o := add(o, byte(0, mload(shr(250, mload(o)))))\n if iszero(lt(o, end)) { break }\n }\n }\n }\n }\n\n /// @dev Returns if this string is a 7-bit ASCII string.\n /// (i.e. all characters codes are in [0..127])\n function is7BitASCII(string memory s) internal pure returns (bool result) {\n /// @solidity memory-safe-assembly\n assembly {\n let mask := shl(7, div(not(0), 255))\n result := 1\n let n := mload(s)\n if n {\n let o := add(s, 0x20)\n let end := add(o, n)\n let last := mload(end)\n mstore(end, 0)\n for {} 1 {} {\n if and(mask, mload(o)) {\n result := 0\n break\n }\n o := add(o, 0x20)\n if iszero(lt(o, end)) { break }\n }\n mstore(end, last)\n }\n }\n }\n\n /// @dev Returns if this string is a 7-bit ASCII string,\n /// AND all characters are in the `allowed` lookup.\n /// Note: If `s` is empty, returns true regardless of `allowed`.\n function is7BitASCII(string memory s, uint128 allowed) internal pure returns (bool result) {\n /// @solidity memory-safe-assembly\n assembly {\n result := 1\n if mload(s) {\n let allowed_ := shr(128, shl(128, allowed))\n let o := add(s, 0x20)\n let end := add(o, mload(s))\n for {} 1 {} {\n result := and(result, shr(byte(0, mload(o)), allowed_))\n o := add(o, 1)\n if iszero(and(result, lt(o, end))) { break }\n }\n }\n }\n }\n\n /// @dev Converts the bytes in the 7-bit ASCII string `s` to\n /// an allowed lookup for use in `is7BitASCII(s, allowed)`.\n /// To save runtime gas, you can cache the result in an immutable variable.\n function to7BitASCIIAllowedLookup(string memory s) internal pure returns (uint128 result) {\n /// @solidity memory-safe-assembly\n assembly {\n if mload(s) {\n let o := add(s, 0x20)\n let end := add(o, mload(s))\n for {} 1 {} {\n result := or(result, shl(byte(0, mload(o)), 1))\n o := add(o, 1)\n if iszero(lt(o, end)) { break }\n }\n if shr(128, result) {\n mstore(0x00, 0xc9807e0d) // `StringNot7BitASCII()`.\n revert(0x1c, 0x04)\n }\n }\n }\n }\n\n /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n /* BYTE STRING OPERATIONS */\n /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n // For performance and bytecode compactness, byte string operations are restricted\n // to 7-bit ASCII strings. All offsets are byte offsets, not UTF character offsets.\n // Usage of byte string operations on charsets with runes spanning two or more bytes\n // can lead to undefined behavior.\n\n /// @dev Returns `subject` all occurrences of `search` replaced with `replacement`.\n function replace(string memory subject, string memory search, string memory replacement)\n internal\n pure\n returns (string memory result)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let subjectLength := mload(subject)\n let searchLength := mload(search)\n let replacementLength := mload(replacement)\n\n subject := add(subject, 0x20)\n search := add(search, 0x20)\n replacement := add(replacement, 0x20)\n result := add(mload(0x40), 0x20)\n\n let subjectEnd := add(subject, subjectLength)\n if iszero(gt(searchLength, subjectLength)) {\n let subjectSearchEnd := add(sub(subjectEnd, searchLength), 1)\n let h := 0\n if iszero(lt(searchLength, 0x20)) { h := keccak256(search, searchLength) }\n let m := shl(3, sub(0x20, and(searchLength, 0x1f)))\n let s := mload(search)\n for {} 1 {} {\n let t := mload(subject)\n // Whether the first `searchLength % 32` bytes of\n // `subject` and `search` matches.\n if iszero(shr(m, xor(t, s))) {\n if h {\n if iszero(eq(keccak256(subject, searchLength), h)) {\n mstore(result, t)\n result := add(result, 1)\n subject := add(subject, 1)\n if iszero(lt(subject, subjectSearchEnd)) { break }\n continue\n }\n }\n // Copy the `replacement` one word at a time.\n for { let o := 0 } 1 {} {\n mstore(add(result, o), mload(add(replacement, o)))\n o := add(o, 0x20)\n if iszero(lt(o, replacementLength)) { break }\n }\n result := add(result, replacementLength)\n subject := add(subject, searchLength)\n if searchLength {\n if iszero(lt(subject, subjectSearchEnd)) { break }\n continue\n }\n }\n mstore(result, t)\n result := add(result, 1)\n subject := add(subject, 1)\n if iszero(lt(subject, subjectSearchEnd)) { break }\n }\n }\n\n let resultRemainder := result\n result := add(mload(0x40), 0x20)\n let k := add(sub(resultRemainder, result), sub(subjectEnd, subject))\n // Copy the rest of the string one word at a time.\n for {} lt(subject, subjectEnd) {} {\n mstore(resultRemainder, mload(subject))\n resultRemainder := add(resultRemainder, 0x20)\n subject := add(subject, 0x20)\n }\n result := sub(result, 0x20)\n let last := add(add(result, 0x20), k) // Zeroize the slot after the string.\n mstore(last, 0)\n mstore(0x40, add(last, 0x20)) // Allocate the memory.\n mstore(result, k) // Store the length.\n }\n }\n\n /// @dev Returns the byte index of the first location of `search` in `subject`,\n /// searching from left to right, starting from `from`.\n /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found.\n function indexOf(string memory subject, string memory search, uint256 from)\n internal\n pure\n returns (uint256 result)\n {\n /// @solidity memory-safe-assembly\n assembly {\n for { let subjectLength := mload(subject) } 1 {} {\n if iszero(mload(search)) {\n if iszero(gt(from, subjectLength)) {\n result := from\n break\n }\n result := subjectLength\n break\n }\n let searchLength := mload(search)\n let subjectStart := add(subject, 0x20)\n\n result := not(0) // Initialize to `NOT_FOUND`.\n subject := add(subjectStart, from)\n let end := add(sub(add(subjectStart, subjectLength), searchLength), 1)\n\n let m := shl(3, sub(0x20, and(searchLength, 0x1f)))\n let s := mload(add(search, 0x20))\n\n if iszero(and(lt(subject, end), lt(from, subjectLength))) { break }\n\n if iszero(lt(searchLength, 0x20)) {\n for { let h := keccak256(add(search, 0x20), searchLength) } 1 {} {\n if iszero(shr(m, xor(mload(subject), s))) {\n if eq(keccak256(subject, searchLength), h) {\n result := sub(subject, subjectStart)\n break\n }\n }\n subject := add(subject, 1)\n if iszero(lt(subject, end)) { break }\n }\n break\n }\n for {} 1 {} {\n if iszero(shr(m, xor(mload(subject), s))) {\n result := sub(subject, subjectStart)\n break\n }\n subject := add(subject, 1)\n if iszero(lt(subject, end)) { break }\n }\n break\n }\n }\n }\n\n /// @dev Returns the byte index of the first location of `search` in `subject`,\n /// searching from left to right.\n /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found.\n function indexOf(string memory subject, string memory search)\n internal\n pure\n returns (uint256 result)\n {\n result = indexOf(subject, search, 0);\n }\n\n /// @dev Returns the byte index of the first location of `search` in `subject`,\n /// searching from right to left, starting from `from`.\n /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found.\n function lastIndexOf(string memory subject, string memory search, uint256 from)\n internal\n pure\n returns (uint256 result)\n {\n /// @solidity memory-safe-assembly\n assembly {\n for {} 1 {} {\n result := not(0) // Initialize to `NOT_FOUND`.\n let searchLength := mload(search)\n if gt(searchLength, mload(subject)) { break }\n let w := result\n\n let fromMax := sub(mload(subject), searchLength)\n if iszero(gt(fromMax, from)) { from := fromMax }\n\n let end := add(add(subject, 0x20), w)\n subject := add(add(subject, 0x20), from)\n if iszero(gt(subject, end)) { break }\n // As this function is not too often used,\n // we shall simply use keccak256 for smaller bytecode size.\n for { let h := keccak256(add(search, 0x20), searchLength) } 1 {} {\n if eq(keccak256(subject, searchLength), h) {\n result := sub(subject, add(end, 1))\n break\n }\n subject := add(subject, w) // `sub(subject, 1)`.\n if iszero(gt(subject, end)) { break }\n }\n break\n }\n }\n }\n\n /// @dev Returns the byte index of the first location of `search` in `subject`,\n /// searching from right to left.\n /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found.\n function lastIndexOf(string memory subject, string memory search)\n internal\n pure\n returns (uint256 result)\n {\n result = lastIndexOf(subject, search, uint256(int256(-1)));\n }\n\n /// @dev Returns true if `search` is found in `subject`, false otherwise.\n function contains(string memory subject, string memory search) internal pure returns (bool) {\n return indexOf(subject, search) != NOT_FOUND;\n }\n\n /// @dev Returns whether `subject` starts with `search`.\n function startsWith(string memory subject, string memory search)\n internal\n pure\n returns (bool result)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let searchLength := mload(search)\n // Just using keccak256 directly is actually cheaper.\n // forgefmt: disable-next-item\n result := and(\n iszero(gt(searchLength, mload(subject))),\n eq(\n keccak256(add(subject, 0x20), searchLength),\n keccak256(add(search, 0x20), searchLength)\n )\n )\n }\n }\n\n /// @dev Returns whether `subject` ends with `search`.\n function endsWith(string memory subject, string memory search)\n internal\n pure\n returns (bool result)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let searchLength := mload(search)\n let subjectLength := mload(subject)\n // Whether `search` is not longer than `subject`.\n let withinRange := iszero(gt(searchLength, subjectLength))\n // Just using keccak256 directly is actually cheaper.\n // forgefmt: disable-next-item\n result := and(\n withinRange,\n eq(\n keccak256(\n // `subject + 0x20 + max(subjectLength - searchLength, 0)`.\n add(add(subject, 0x20), mul(withinRange, sub(subjectLength, searchLength))),\n searchLength\n ),\n keccak256(add(search, 0x20), searchLength)\n )\n )\n }\n }\n\n /// @dev Returns `subject` repeated `times`.\n function repeat(string memory subject, uint256 times)\n internal\n pure\n returns (string memory result)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let subjectLength := mload(subject)\n if iszero(or(iszero(times), iszero(subjectLength))) {\n subject := add(subject, 0x20)\n result := mload(0x40)\n let output := add(result, 0x20)\n for {} 1 {} {\n // Copy the `subject` one word at a time.\n for { let o := 0 } 1 {} {\n mstore(add(output, o), mload(add(subject, o)))\n o := add(o, 0x20)\n if iszero(lt(o, subjectLength)) { break }\n }\n output := add(output, subjectLength)\n times := sub(times, 1)\n if iszero(times) { break }\n }\n mstore(output, 0) // Zeroize the slot after the string.\n let resultLength := sub(output, add(result, 0x20))\n mstore(result, resultLength) // Store the length.\n mstore(0x40, add(result, add(resultLength, 0x40))) // Allocate the memory.\n }\n }\n }\n\n /// @dev Returns a copy of `subject` sliced from `start` to `end` (exclusive).\n /// `start` and `end` are byte offsets.\n function slice(string memory subject, uint256 start, uint256 end)\n internal\n pure\n returns (string memory result)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let subjectLength := mload(subject)\n if iszero(gt(subjectLength, end)) { end := subjectLength }\n if iszero(gt(subjectLength, start)) { start := subjectLength }\n if lt(start, end) {\n result := mload(0x40)\n let resultLength := sub(end, start)\n mstore(result, resultLength)\n subject := add(subject, start)\n let w := not(0x1f)\n // Copy the `subject` one word at a time, backwards.\n for { let o := and(add(resultLength, 0x1f), w) } 1 {} {\n mstore(add(result, o), mload(add(subject, o)))\n o := add(o, w) // `sub(o, 0x20)`.\n if iszero(o) { break }\n }\n // Zeroize the slot after the string.\n mstore(add(add(result, 0x20), resultLength), 0)\n mstore(0x40, add(result, add(resultLength, 0x40))) // Allocate the memory.\n }\n }\n }\n\n /// @dev Returns a copy of `subject` sliced from `start` to the end of the string.\n /// `start` is a byte offset.\n function slice(string memory subject, uint256 start)\n internal\n pure\n returns (string memory result)\n {\n result = slice(subject, start, uint256(int256(-1)));\n }\n\n /// @dev Returns all the indices of `search` in `subject`.\n /// The indices are byte offsets.\n function indicesOf(string memory subject, string memory search)\n internal\n pure\n returns (uint256[] memory result)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let subjectLength := mload(subject)\n let searchLength := mload(search)\n\n if iszero(gt(searchLength, subjectLength)) {\n subject := add(subject, 0x20)\n search := add(search, 0x20)\n result := add(mload(0x40), 0x20)\n\n let subjectStart := subject\n let subjectSearchEnd := add(sub(add(subject, subjectLength), searchLength), 1)\n let h := 0\n if iszero(lt(searchLength, 0x20)) { h := keccak256(search, searchLength) }\n let m := shl(3, sub(0x20, and(searchLength, 0x1f)))\n let s := mload(search)\n for {} 1 {} {\n let t := mload(subject)\n // Whether the first `searchLength % 32` bytes of\n // `subject` and `search` matches.\n if iszero(shr(m, xor(t, s))) {\n if h {\n if iszero(eq(keccak256(subject, searchLength), h)) {\n subject := add(subject, 1)\n if iszero(lt(subject, subjectSearchEnd)) { break }\n continue\n }\n }\n // Append to `result`.\n mstore(result, sub(subject, subjectStart))\n result := add(result, 0x20)\n // Advance `subject` by `searchLength`.\n subject := add(subject, searchLength)\n if searchLength {\n if iszero(lt(subject, subjectSearchEnd)) { break }\n continue\n }\n }\n subject := add(subject, 1)\n if iszero(lt(subject, subjectSearchEnd)) { break }\n }\n let resultEnd := result\n // Assign `result` to the free memory pointer.\n result := mload(0x40)\n // Store the length of `result`.\n mstore(result, shr(5, sub(resultEnd, add(result, 0x20))))\n // Allocate memory for result.\n // We allocate one more word, so this array can be recycled for {split}.\n mstore(0x40, add(resultEnd, 0x20))\n }\n }\n }\n\n /// @dev Returns a arrays of strings based on the `delimiter` inside of the `subject` string.\n function split(string memory subject, string memory delimiter)\n internal\n pure\n returns (string[] memory result)\n {\n uint256[] memory indices = indicesOf(subject, delimiter);\n /// @solidity memory-safe-assembly\n assembly {\n let w := not(0x1f)\n let indexPtr := add(indices, 0x20)\n let indicesEnd := add(indexPtr, shl(5, add(mload(indices), 1)))\n mstore(add(indicesEnd, w), mload(subject))\n mstore(indices, add(mload(indices), 1))\n let prevIndex := 0\n for {} 1 {} {\n let index := mload(indexPtr)\n mstore(indexPtr, 0x60)\n if iszero(eq(index, prevIndex)) {\n let element := mload(0x40)\n let elementLength := sub(index, prevIndex)\n mstore(element, elementLength)\n // Copy the `subject` one word at a time, backwards.\n for { let o := and(add(elementLength, 0x1f), w) } 1 {} {\n mstore(add(element, o), mload(add(add(subject, prevIndex), o)))\n o := add(o, w) // `sub(o, 0x20)`.\n if iszero(o) { break }\n }\n // Zeroize the slot after the string.\n mstore(add(add(element, 0x20), elementLength), 0)\n // Allocate memory for the length and the bytes,\n // rounded up to a multiple of 32.\n mstore(0x40, add(element, and(add(elementLength, 0x3f), w)))\n // Store the `element` into the array.\n mstore(indexPtr, element)\n }\n prevIndex := add(index, mload(delimiter))\n indexPtr := add(indexPtr, 0x20)\n if iszero(lt(indexPtr, indicesEnd)) { break }\n }\n result := indices\n if iszero(mload(delimiter)) {\n result := add(indices, 0x20)\n mstore(result, sub(mload(indices), 2))\n }\n }\n }\n\n /// @dev Returns a concatenated string of `a` and `b`.\n /// Cheaper than `string.concat()` and does not de-align the free memory pointer.\n function concat(string memory a, string memory b)\n internal\n pure\n returns (string memory result)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let w := not(0x1f)\n result := mload(0x40)\n let aLength := mload(a)\n // Copy `a` one word at a time, backwards.\n for { let o := and(add(aLength, 0x20), w) } 1 {} {\n mstore(add(result, o), mload(add(a, o)))\n o := add(o, w) // `sub(o, 0x20)`.\n if iszero(o) { break }\n }\n let bLength := mload(b)\n let output := add(result, aLength)\n // Copy `b` one word at a time, backwards.\n for { let o := and(add(bLength, 0x20), w) } 1 {} {\n mstore(add(output, o), mload(add(b, o)))\n o := add(o, w) // `sub(o, 0x20)`.\n if iszero(o) { break }\n }\n let totalLength := add(aLength, bLength)\n let last := add(add(result, 0x20), totalLength)\n mstore(last, 0) // Zeroize the slot after the string.\n mstore(result, totalLength) // Store the length.\n mstore(0x40, add(last, 0x20)) // Allocate the memory.\n }\n }\n\n /// @dev Returns a copy of the string in either lowercase or UPPERCASE.\n /// WARNING! This function is only compatible with 7-bit ASCII strings.\n function toCase(string memory subject, bool toUpper)\n internal\n pure\n returns (string memory result)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let length := mload(subject)\n if length {\n result := add(mload(0x40), 0x20)\n subject := add(subject, 1)\n let flags := shl(add(70, shl(5, toUpper)), 0x3ffffff)\n let w := not(0)\n for { let o := length } 1 {} {\n o := add(o, w)\n let b := and(0xff, mload(add(subject, o)))\n mstore8(add(result, o), xor(b, and(shr(b, flags), 0x20)))\n if iszero(o) { break }\n }\n result := mload(0x40)\n mstore(result, length) // Store the length.\n let last := add(add(result, 0x20), length)\n mstore(last, 0) // Zeroize the slot after the string.\n mstore(0x40, add(last, 0x20)) // Allocate the memory.\n }\n }\n }\n\n /// @dev Returns a string from a small bytes32 string.\n /// `s` must be null-terminated, or behavior will be undefined.\n function fromSmallString(bytes32 s) internal pure returns (string memory result) {\n /// @solidity memory-safe-assembly\n assembly {\n result := mload(0x40)\n let n := 0\n for {} byte(n, s) { n := add(n, 1) } {} // Scan for '\\0'.\n mstore(result, n) // Store the length.\n let o := add(result, 0x20)\n mstore(o, s) // Store the bytes of the string.\n mstore(add(o, n), 0) // Zeroize the slot after the string.\n mstore(0x40, add(result, 0x40)) // Allocate the memory.\n }\n }\n\n /// @dev Returns the small string, with all bytes after the first null byte zeroized.\n function normalizeSmallString(bytes32 s) internal pure returns (bytes32 result) {\n /// @solidity memory-safe-assembly\n assembly {\n for {} byte(result, s) { result := add(result, 1) } {} // Scan for '\\0'.\n mstore(0x00, s)\n mstore(result, 0x00)\n result := mload(0x00)\n }\n }\n\n /// @dev Returns the string as a normalized null-terminated small string.\n function toSmallString(string memory s) internal pure returns (bytes32 result) {\n /// @solidity memory-safe-assembly\n assembly {\n result := mload(s)\n if iszero(lt(result, 33)) {\n mstore(0x00, 0xec92f9a3) // `TooBigForSmallString()`.\n revert(0x1c, 0x04)\n }\n result := shl(shl(3, sub(32, result)), mload(add(s, result)))\n }\n }\n\n /// @dev Returns a lowercased copy of the string.\n /// WARNING! This function is only compatible with 7-bit ASCII strings.\n function lower(string memory subject) internal pure returns (string memory result) {\n result = toCase(subject, false);\n }\n\n /// @dev Returns an UPPERCASED copy of the string.\n /// WARNING! This function is only compatible with 7-bit ASCII strings.\n function upper(string memory subject) internal pure returns (string memory result) {\n result = toCase(subject, true);\n }\n\n /// @dev Escapes the string to be used within HTML tags.\n function escapeHTML(string memory s) internal pure returns (string memory result) {\n /// @solidity memory-safe-assembly\n assembly {\n let end := add(s, mload(s))\n result := add(mload(0x40), 0x20)\n // Store the bytes of the packed offsets and strides into the scratch space.\n // `packed = (stride << 5) | offset`. Max offset is 20. Max stride is 6.\n mstore(0x1f, 0x900094)\n mstore(0x08, 0xc0000000a6ab)\n // Store \""&'<>\" into the scratch space.\n mstore(0x00, shl(64, 0x2671756f743b26616d703b262333393b266c743b2667743b))\n for {} iszero(eq(s, end)) {} {\n s := add(s, 1)\n let c := and(mload(s), 0xff)\n // Not in `[\"\\\"\",\"'\",\"&\",\"<\",\">\"]`.\n if iszero(and(shl(c, 1), 0x500000c400000000)) {\n mstore8(result, c)\n result := add(result, 1)\n continue\n }\n let t := shr(248, mload(c))\n mstore(result, mload(and(t, 0x1f)))\n result := add(result, shr(5, t))\n }\n let last := result\n mstore(last, 0) // Zeroize the slot after the string.\n result := mload(0x40)\n mstore(result, sub(last, add(result, 0x20))) // Store the length.\n mstore(0x40, add(last, 0x20)) // Allocate the memory.\n }\n }\n\n /// @dev Escapes the string to be used within double-quotes in a JSON.\n /// If `addDoubleQuotes` is true, the result will be enclosed in double-quotes.\n function escapeJSON(string memory s, bool addDoubleQuotes)\n internal\n pure\n returns (string memory result)\n {\n /// @solidity memory-safe-assembly\n assembly {\n let end := add(s, mload(s))\n result := add(mload(0x40), 0x20)\n if addDoubleQuotes {\n mstore8(result, 34)\n result := add(1, result)\n }\n // Store \"\\\\u0000\" in scratch space.\n // Store \"0123456789abcdef\" in scratch space.\n // Also, store `{0x08:\"b\", 0x09:\"t\", 0x0a:\"n\", 0x0c:\"f\", 0x0d:\"r\"}`.\n // into the scratch space.\n mstore(0x15, 0x5c75303030303031323334353637383961626364656662746e006672)\n // Bitmask for detecting `[\"\\\"\",\"\\\\\"]`.\n let e := or(shl(0x22, 1), shl(0x5c, 1))\n for {} iszero(eq(s, end)) {} {\n s := add(s, 1)\n let c := and(mload(s), 0xff)\n if iszero(lt(c, 0x20)) {\n if iszero(and(shl(c, 1), e)) {\n // Not in `[\"\\\"\",\"\\\\\"]`.\n mstore8(result, c)\n result := add(result, 1)\n continue\n }\n mstore8(result, 0x5c) // \"\\\\\".\n mstore8(add(result, 1), c)\n result := add(result, 2)\n continue\n }\n if iszero(and(shl(c, 1), 0x3700)) {\n // Not in `[\"\\b\",\"\\t\",\"\\n\",\"\\f\",\"\\d\"]`.\n mstore8(0x1d, mload(shr(4, c))) // Hex value.\n mstore8(0x1e, mload(and(c, 15))) // Hex value.\n mstore(result, mload(0x19)) // \"\\\\u00XX\".\n result := add(result, 6)\n continue\n }\n mstore8(result, 0x5c) // \"\\\\\".\n mstore8(add(result, 1), mload(add(c, 8)))\n result := add(result, 2)\n }\n if addDoubleQuotes {\n mstore8(result, 34)\n result := add(1, result)\n }\n let last := result\n mstore(last, 0) // Zeroize the slot after the string.\n result := mload(0x40)\n mstore(result, sub(last, add(result, 0x20))) // Store the length.\n mstore(0x40, add(last, 0x20)) // Allocate the memory.\n }\n }\n\n /// @dev Escapes the string to be used within double-quotes in a JSON.\n function escapeJSON(string memory s) internal pure returns (string memory result) {\n result = escapeJSON(s, false);\n }\n\n /// @dev Returns whether `a` equals `b`.\n function eq(string memory a, string memory b) internal pure returns (bool result) {\n /// @solidity memory-safe-assembly\n assembly {\n result := eq(keccak256(add(a, 0x20), mload(a)), keccak256(add(b, 0x20), mload(b)))\n }\n }\n\n /// @dev Returns whether `a` equals `b`, where `b` is a null-terminated small string.\n function eqs(string memory a, bytes32 b) internal pure returns (bool result) {\n /// @solidity memory-safe-assembly\n assembly {\n // These should be evaluated on compile time, as far as possible.\n let m := not(shl(7, div(not(iszero(b)), 255))) // `0x7f7f ...`.\n let x := not(or(m, or(b, add(m, and(b, m)))))\n let r := shl(7, iszero(iszero(shr(128, x))))\n r := or(r, shl(6, iszero(iszero(shr(64, shr(r, x))))))\n r := or(r, shl(5, lt(0xffffffff, shr(r, x))))\n r := or(r, shl(4, lt(0xffff, shr(r, x))))\n r := or(r, shl(3, lt(0xff, shr(r, x))))\n // forgefmt: disable-next-item\n result := gt(eq(mload(a), add(iszero(x), xor(31, shr(3, r)))),\n xor(shr(add(8, r), b), shr(add(8, r), mload(add(a, 0x20)))))\n }\n }\n\n /// @dev Packs a single string with its length into a single word.\n /// Returns `bytes32(0)` if the length is zero or greater than 31.\n function packOne(string memory a) internal pure returns (bytes32 result) {\n /// @solidity memory-safe-assembly\n assembly {\n // We don't need to zero right pad the string,\n // since this is our own custom non-standard packing scheme.\n result :=\n mul(\n // Load the length and the bytes.\n mload(add(a, 0x1f)),\n // `length != 0 && length < 32`. Abuses underflow.\n // Assumes that the length is valid and within the block gas limit.\n lt(sub(mload(a), 1), 0x1f)\n )\n }\n }\n\n /// @dev Unpacks a string packed using {packOne}.\n /// Returns the empty string if `packed` is `bytes32(0)`.\n /// If `packed` is not an output of {packOne}, the output behavior is undefined.\n function unpackOne(bytes32 packed) internal pure returns (string memory result) {\n /// @solidity memory-safe-assembly\n assembly {\n result := mload(0x40) // Grab the free memory pointer.\n mstore(0x40, add(result, 0x40)) // Allocate 2 words (1 for the length, 1 for the bytes).\n mstore(result, 0) // Zeroize the length slot.\n mstore(add(result, 0x1f), packed) // Store the length and bytes.\n mstore(add(add(result, 0x20), mload(result)), 0) // Right pad with zeroes.\n }\n }\n\n /// @dev Packs two strings with their lengths into a single word.\n /// Returns `bytes32(0)` if combined length is zero or greater than 30.\n function packTwo(string memory a, string memory b) internal pure returns (bytes32 result) {\n /// @solidity memory-safe-assembly\n assembly {\n let aLength := mload(a)\n // We don't need to zero right pad the strings,\n // since this is our own custom non-standard packing scheme.\n result :=\n mul(\n or( // Load the length and the bytes of `a` and `b`.\n shl(shl(3, sub(0x1f, aLength)), mload(add(a, aLength))),\n mload(sub(add(b, 0x1e), aLength))\n ),\n // `totalLength != 0 && totalLength < 31`. Abuses underflow.\n // Assumes that the lengths are valid and within the block gas limit.\n lt(sub(add(aLength, mload(b)), 1), 0x1e)\n )\n }\n }\n\n /// @dev Unpacks strings packed using {packTwo}.\n /// Returns the empty strings if `packed` is `bytes32(0)`.\n /// If `packed` is not an output of {packTwo}, the output behavior is undefined.\n function unpackTwo(bytes32 packed)\n internal\n pure\n returns (string memory resultA, string memory resultB)\n {\n /// @solidity memory-safe-assembly\n assembly {\n resultA := mload(0x40) // Grab the free memory pointer.\n resultB := add(resultA, 0x40)\n // Allocate 2 words for each string (1 for the length, 1 for the byte). Total 4 words.\n mstore(0x40, add(resultB, 0x40))\n // Zeroize the length slots.\n mstore(resultA, 0)\n mstore(resultB, 0)\n // Store the lengths and bytes.\n mstore(add(resultA, 0x1f), packed)\n mstore(add(resultB, 0x1f), mload(add(add(resultA, 0x20), mload(resultA))))\n // Right pad with zeroes.\n mstore(add(add(resultA, 0x20), mload(resultA)), 0)\n mstore(add(add(resultB, 0x20), mload(resultB)), 0)\n }\n }\n\n /// @dev Directly returns `a` without copying.\n function directReturn(string memory a) internal pure {\n assembly {\n // Assumes that the string does not start from the scratch space.\n let retStart := sub(a, 0x20)\n let retUnpaddedSize := add(mload(a), 0x40)\n // Right pad with zeroes. Just in case the string is produced\n // by a method that doesn't zero right pad.\n mstore(add(retStart, retUnpaddedSize), 0)\n mstore(retStart, 0x20) // Store the return offset.\n // End the transaction, returning the string.\n return(retStart, and(not(0x1f), add(0x1f, retUnpaddedSize)))\n }\n }\n}\n"}},"deployment":{"transactionHash":"0x304a03f7699d252357f545e6847c23fbde0fd45238034e09e8fcfdbec3607ad5","blockNumber":"22697476","transactionIndex":"12","deployer":"0xfFFffFb57D1266CEa6e5648418487083854fdDC9"},"matchId":"6439339","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2025-06-13T18:38:37Z","match":"exact_match","chainId":"1","address":"0x117553ba213Ee4fa51d91DbafF7059F0BE3A6779"}