Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IUniswapV2Router02
•    - function factory()
•    - function WETH()
•    - function addLiquidity(
•    - function addLiquidityETH(
•    - function swapExactTokensForETHSupport ...
• library LibMap
•    - function get(Uint8Map storage map, ui ...
•    - function set(Uint8Map storage map, ui ...
•    - function get(Uint16Map storage map, u ...
•    - function set(Uint16Map storage map, u ...
•    - function get(Uint32Map storage map, u ...
•    - function set(Uint32Map storage map, u ...
•    - function get(Uint40Map storage map, u ...
•    - function set(Uint40Map storage map, u ...
•    - function get(Uint64Map storage map, u ...
•    - function set(Uint64Map storage map, u ...
•    - function get(Uint128Map storage map, ...
•    - function set(Uint128Map storage map, ...
•    - function get(mapping(uint256 =&gt ...
•    - function set(
•    - function searchSorted(Uint8Map storag ...
•    - function searchSorted(Uint16Map stora ...
•    - function searchSorted(Uint32Map stora ...
•    - function searchSorted(Uint40Map stora ...
•    - function searchSorted(Uint64Map stora ...
•    - function searchSorted(Uint128Map stor ...
•    - function searchSorted(
•    - function _rawDiv(uint256 x, uint256 y ...
•    - function _rawMod(uint256 x, uint256 y ...
• library LibString
•    - function toString(uint256 value)
•    - function toString(int256 value)
•    - function toHexString(uint256 value, u ...
•    - function toHexStringNoPrefix(uint256 ...
•    - function toHexString(uint256 value)
•    - function toMinimalHexString(uint256 v ...
•    - function toMinimalHexStringNoPrefix(u ...
•    - function toHexStringNoPrefix(uint256 ...
•    - function toHexStringChecksummed(addre ...
•    - function toHexString(address value)
•    - function toHexStringNoPrefix(address ...
•    - function toHexString(bytes memory raw ...
•    - function toHexStringNoPrefix(bytes me ...
•    - function runeCount(string memory s)
•    - function is7BitASCII(string memory s)
•    - function replace(string memory subjec ...
•    - function indexOf(string memory subjec ...
•    - function indexOf(string memory subjec ...
•    - function lastIndexOf(string memory su ...
•    - function lastIndexOf(string memory su ...
•    - function contains(string memory subje ...
•    - function startsWith(string memory sub ...
•    - function endsWith(string memory subje ...
•    - function repeat(string memory subject ...
•    - function slice(string memory subject, ...
•    - function slice(string memory subject, ...
•    - function indicesOf(string memory subj ...
•    - function split(string memory subject, ...
•    - function concat(string memory a, stri ...
•    - function toCase(string memory subject ...
•    - function fromSmallString(bytes32 s)
•    - function normalizeSmallString(bytes32 ...
•    - function toSmallString(string memory ...
•    - function lower(string memory subject)
•    - function upper(string memory subject)
•    - function escapeHTML(string memory s)
•    - function escapeJSON(string memory s, ...
•    - function escapeJSON(string memory s)
•    - function eq(string memory a, string m ...
•    - function eqs(string memory a, bytes32 ...
•    - function packOne(string memory a)
•    - function unpackOne(bytes32 packed)
•    - function packTwo(string memory a, str ...
•    - function unpackTwo(bytes32 packed)
•    - function directReturn(string memory a ...
•    - function _guardInitializeOwner()
•    - function _initializeOwner(address new ...
•    - function _setOwner(address newOwner)
•    - function _checkOwner()
•    - function _ownershipHandoverValidFor()
•    - function transferOwnership(address ne ...
•    - function renounceOwnership()
•    - function requestOwnershipHandover()
•    - function cancelOwnershipHandover()
•    - function completeOwnershipHandover(ad ...
•    - function owner()
•    - function ownershipHandoverExpiresAt(a ...
•  contract ERC_YB_NFT
•    - function _getDN404NFTStorage()
•    - function name()
•    - function symbol()
•    - function tokenURI(uint256 id)
•    - function totalSupply()
•    - function balanceOf(address nftOwner)
•    - function ownerOf(uint256 id)
•    - function ownerAt(uint256 id)
•    - function approve(address spender, uin ...
•    - function getApproved(uint256 id)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address nft ...
•    - function transferFrom(address from, a ...
•    - function safeTransferFrom(address fro ...
•    - function safeTransferFrom(address fro ...
•    - function supportsInterface(bytes4 int ...
•    - function owner()
•    - function pullOwner()
•    - function baseERC20()
•    - function _readString(uint256 fnSelect ...
•    - function _readWord(uint256 fnSelector ...
•    - function _calldataload(uint256 offset ...
•    - function _hasCode(address a)
•    - function _checkOnERC721Received(addre ...
•    - function _getDN404Storage()
•    - function _initializeDN404(
•    - function _unit()
•    - function name()
•    - function symbol()
•    - function tokenURI(uint256 id)
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address owner)
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transfer(address to, uint256 ...
•    - function transferFrom(address from, a ...
•    - function _givePermit2DefaultInfiniteA ...
•    - function _mint(address to, uint256 am ...
•    - function _burn(address from, uint256 ...
•    - function _transfer(address from, addr ...
•    - function _addToBurnedPool(uint256 tot ...
•    - function _transferFromNFT(address fro ...
•    - function _approve(address owner, addr ...
•    - function _getAux(address owner)
•    - function _setAux(address owner, uint8 ...
•    - function getSkipNFT(address owner)
•    - function setSkipNFT(bool skipNFT)
•    - function _setSkipNFT(address owner, b ...
•    - function _addressData(address owner)
•    - function _registerAndResolveAlias(Add ...
•    - function mirrorERC721()
•    - function _totalNFTSupply()
•    - function _balanceOfNFT(address owner)
•    - function _ownerAt(uint256 id)
•    - function _ownerOf(uint256 id)
•    - function _exists(uint256 id)
•    - function _getApproved(uint256 id)
•    - function _approveNFT(address spender, ...
•    - function _setApprovalForAll(address o ...
•    - function _ownershipIndex(uint256 i)
•    - function _ownedIndex(uint256 i)
•    - function _get(Uint32Map storage map, ...
•    - function _set(Uint32Map storage map, ...
•    - function _setOwnerAliasAndOwnedIndex(
•    - function _get(Bitmap storage bitmap, ...
•    - function _set(Bitmap storage bitmap, ...
•    - function _ref(AddressPairToUint256Ref ...
•    - function _wrapNFTId(uint256 id, uint2 ...
•    - function _totalSupplyOverflows(uint25 ...
•    - function _zeroFloorSub(uint256 x, uin ...
•    - function _toUint(bool b)
•    - function _packedLogsMalloc(uint256 n)
•    - function _packedLogsSet(_PackedLogs m ...
•    - function _packedLogsAppend(_PackedLog ...
•    - function _packedLogsSend(_PackedLogs ...
•    - function _hasCode(address a)
•    - function _calldataload(uint256 offset ...
•    - function _return(uint256 x)
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address from, a ...
• library Strings
•    - function toString(uint256 value)
• interface IUniswapV2Factory
•    - function feeTo()
•    - function feeToSetter()
•    - function getPair(address tokenA, addr ...
•    - function allPairs(uint256)
•    - function allPairsLength()
•    - function createPair(address tokenA, a ...
•    - function setFeeTo(address)
•    - function setFeeToSetter(address)
•  contract YBOYZ is ERC_YB, Ownable *
•    - function name()
•    - function symbol()
•    - function setTokenURI(string memory _t ...
•    - function tokenURI(uint256 id)
•    - function openTrading()
•    - function excludeFromMaxTransaction(ad ...
•    - function excludeFromFees(address acco ...
•    - function _setAutomatedMarketMakerPair ...
•    - function isExcludedFromFees(address a ...
•    - function _transfer(address from, addr ...
•    - function swapTokensForEth(uint256 tok ...
•    - function setLimits(uint256 _maxTransa ...
•    - function retrieveStuckEth()
•    - function removeStuckToken(address _ad ...
•    - function setSwapTokensAtAmount(uint25 ...
•    - function manualSwap(uint256 percent)
•    - function setMarketingWallet(address _ ...
•    - function setFee(uint256 _buyFee, uint ...
•    - function swapBack()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2024-02-16
*/

/**

Twitter: https://twitter.com/YardBoyzERCYB
Telegram: https://t.me/YardBoyzPortal
Website: https://yardboyz.xyz

*/

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

interface IUniswapV2Router02 {
    function factory() external pure returns (address);

    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    )
    external
    returns (
        uint256 amountA,
        uint256 amountB,
        uint256 liquidity
    );

    function addLiquidityETH(
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    )
    external
    payable
    returns (
        uint256 amountToken,
        uint256 amountETH,
        uint256 liquidity
    );

    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;
}


/// @notice Library for storage of packed unsigned integers.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibMap.sol)
library LibMap {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          STRUCTS                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev A uint8 map in storage.
    struct Uint8Map {
        mapping(uint256 => uint256) map;
    }

    /// @dev A uint16 map in storage.
    struct Uint16Map {
        mapping(uint256 => uint256) map;
    }

    /// @dev A uint32 map in storage.
    struct Uint32Map {
        mapping(uint256 => uint256) map;
    }

    /// @dev A uint40 map in storage. Useful for storing timestamps up to 34841 A.D.
    struct Uint40Map {
        mapping(uint256 => uint256) map;
    }

    /// @dev A uint64 map in storage.
    struct Uint64Map {
        mapping(uint256 => uint256) map;
    }

    /// @dev A uint128 map in storage.
    struct Uint128Map {
        mapping(uint256 => uint256) map;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                     GETTERS / SETTERS                      */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the uint8 value at `index` in `map`.
    function get(Uint8Map storage map, uint256 index) internal view returns (uint8 result) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, map.slot)
            mstore(0x00, shr(5, index))
            result := byte(and(31, not(index)), sload(keccak256(0x00, 0x40)))
        }
    }

    /// @dev Updates the uint8 value at `index` in `map`.
    function set(Uint8Map storage map, uint256 index, uint8 value) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, map.slot)
            mstore(0x00, shr(5, index))
            let s := keccak256(0x00, 0x40) // Storage slot.
            mstore(0x00, sload(s))
            mstore8(and(31, not(index)), value)
            sstore(s, mload(0x00))
        }
    }

    /// @dev Returns the uint16 value at `index` in `map`.
    function get(Uint16Map storage map, uint256 index) internal view returns (uint16 result) {
        result = uint16(map.map[index >> 4] >> ((index & 15) << 4));
    }

    /// @dev Updates the uint16 value at `index` in `map`.
    function set(Uint16Map storage map, uint256 index, uint16 value) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, map.slot)
            mstore(0x00, shr(4, index))
            let s := keccak256(0x00, 0x40) // Storage slot.
            let o := shl(4, and(index, 15)) // Storage slot offset (bits).
            let v := sload(s) // Storage slot value.
            let m := 0xffff // Value mask.
            sstore(s, xor(v, shl(o, and(m, xor(shr(o, v), value)))))
        }
    }

    /// @dev Returns the uint32 value at `index` in `map`.
    function get(Uint32Map storage map, uint256 index) internal view returns (uint32 result) {
        result = uint32(map.map[index >> 3] >> ((index & 7) << 5));
    }

    /// @dev Updates the uint32 value at `index` in `map`.
    function set(Uint32Map storage map, uint256 index, uint32 value) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, map.slot)
            mstore(0x00, shr(3, index))
            let s := keccak256(0x00, 0x40) // Storage slot.
            let o := shl(5, and(index, 7)) // Storage slot offset (bits).
            let v := sload(s) // Storage slot value.
            let m := 0xffffffff // Value mask.
            sstore(s, xor(v, shl(o, and(m, xor(shr(o, v), value)))))
        }
    }

    /// @dev Returns the uint40 value at `index` in `map`.
    function get(Uint40Map storage map, uint256 index) internal view returns (uint40 result) {
        unchecked {
            result = uint40(map.map[index / 6] >> ((index % 6) * 40));
        }
    }

    /// @dev Updates the uint40 value at `index` in `map`.
    function set(Uint40Map storage map, uint256 index, uint40 value) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, map.slot)
            mstore(0x00, div(index, 6))
            let s := keccak256(0x00, 0x40) // Storage slot.
            let o := mul(40, mod(index, 6)) // Storage slot offset (bits).
            let v := sload(s) // Storage slot value.
            let m := 0xffffffffff // Value mask.
            sstore(s, xor(v, shl(o, and(m, xor(shr(o, v), value)))))
        }
    }

    /// @dev Returns the uint64 value at `index` in `map`.
    function get(Uint64Map storage map, uint256 index) internal view returns (uint64 result) {
        result = uint64(map.map[index >> 2] >> ((index & 3) << 6));
    }

    /// @dev Updates the uint64 value at `index` in `map`.
    function set(Uint64Map storage map, uint256 index, uint64 value) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, map.slot)
            mstore(0x00, shr(2, index))
            let s := keccak256(0x00, 0x40) // Storage slot.
            let o := shl(6, and(index, 3)) // Storage slot offset (bits).
            let v := sload(s) // Storage slot value.
            let m := 0xffffffffffffffff // Value mask.
            sstore(s, xor(v, shl(o, and(m, xor(shr(o, v), value)))))
        }
    }

    /// @dev Returns the uint128 value at `index` in `map`.
    function get(Uint128Map storage map, uint256 index) internal view returns (uint128 result) {
        result = uint128(map.map[index >> 1] >> ((index & 1) << 7));
    }

    /// @dev Updates the uint128 value at `index` in `map`.
    function set(Uint128Map storage map, uint256 index, uint128 value) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, map.slot)
            mstore(0x00, shr(1, index))
            let s := keccak256(0x00, 0x40) // Storage slot.
            let o := shl(7, and(index, 1)) // Storage slot offset (bits).
            let v := sload(s) // Storage slot value.
            let m := 0xffffffffffffffffffffffffffffffff // Value mask.
            sstore(s, xor(v, shl(o, and(m, xor(shr(o, v), value)))))
        }
    }

    /// @dev Returns the value at `index` in `map`.
    function get(mapping(uint256 => uint256) storage map, uint256 index, uint256 bitWidth)
    internal
    view
    returns (uint256 result)
    {
        unchecked {
            uint256 d = _rawDiv(256, bitWidth); // Bucket size.
            uint256 m = (1 << bitWidth) - 1; // Value mask.
            result = (map[_rawDiv(index, d)] >> (_rawMod(index, d) * bitWidth)) & m;
        }
    }

    /// @dev Updates the value at `index` in `map`.
    function set(
        mapping(uint256 => uint256) storage map,
        uint256 index,
        uint256 value,
        uint256 bitWidth
    ) internal {
        unchecked {
            uint256 d = _rawDiv(256, bitWidth); // Bucket size.
            uint256 m = (1 << bitWidth) - 1; // Value mask.
            uint256 o = _rawMod(index, d) * bitWidth; // Storage slot offset (bits).
            map[_rawDiv(index, d)] ^= (((map[_rawDiv(index, d)] >> o) ^ value) & m) << o;
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       BINARY SEARCH                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    // The following functions search in the range of [`start`, `end`)
    // (i.e. `start <= index < end`).
    // The range must be sorted in ascending order.
    // `index` precedence: equal to > nearest before > nearest after.
    // An invalid search range will simply return `(found = false, index = start)`.

    /// @dev Returns whether `map` contains `needle`, and the index of `needle`.
    function searchSorted(Uint8Map storage map, uint8 needle, uint256 start, uint256 end)
    internal
    view
    returns (bool found, uint256 index)
    {
        return searchSorted(map.map, needle, start, end, 8);
    }

    /// @dev Returns whether `map` contains `needle`, and the index of `needle`.
    function searchSorted(Uint16Map storage map, uint16 needle, uint256 start, uint256 end)
    internal
    view
    returns (bool found, uint256 index)
    {
        return searchSorted(map.map, needle, start, end, 16);
    }

    /// @dev Returns whether `map` contains `needle`, and the index of `needle`.
    function searchSorted(Uint32Map storage map, uint32 needle, uint256 start, uint256 end)
    internal
    view
    returns (bool found, uint256 index)
    {
        return searchSorted(map.map, needle, start, end, 32);
    }

    /// @dev Returns whether `map` contains `needle`, and the index of `needle`.
    function searchSorted(Uint40Map storage map, uint40 needle, uint256 start, uint256 end)
    internal
    view
    returns (bool found, uint256 index)
    {
        return searchSorted(map.map, needle, start, end, 40);
    }

    /// @dev Returns whether `map` contains `needle`, and the index of `needle`.
    function searchSorted(Uint64Map storage map, uint64 needle, uint256 start, uint256 end)
    internal
    view
    returns (bool found, uint256 index)
    {
        return searchSorted(map.map, needle, start, end, 64);
    }

    /// @dev Returns whether `map` contains `needle`, and the index of `needle`.
    function searchSorted(Uint128Map storage map, uint128 needle, uint256 start, uint256 end)
    internal
    view
    returns (bool found, uint256 index)
    {
        return searchSorted(map.map, needle, start, end, 128);
    }

    /// @dev Returns whether `map` contains `needle`, and the index of `needle`.
    function searchSorted(
        mapping(uint256 => uint256) storage map,
        uint256 needle,
        uint256 start,
        uint256 end,
        uint256 bitWidth
    ) internal view returns (bool found, uint256 index) {
        unchecked {
            if (start >= end) end = start;
            uint256 t;
            uint256 o = start - 1; // Offset to derive the actual index.
            uint256 l = 1; // Low.
            uint256 d = _rawDiv(256, bitWidth); // Bucket size.
            uint256 m = (1 << bitWidth) - 1; // Value mask.
            uint256 h = end - start; // High.
            while (true) {
                index = (l & h) + ((l ^ h) >> 1);
                if (l > h) break;
                t = (map[_rawDiv(index + o, d)] >> (_rawMod(index + o, d) * bitWidth)) & m;
                if (t == needle) break;
                if (needle <= t) h = index - 1;
                else l = index + 1;
            }
        /// @solidity memory-safe-assembly
            assembly {
                m := or(iszero(index), iszero(bitWidth))
                found := iszero(or(xor(t, needle), m))
                index := add(o, xor(index, mul(xor(index, 1), m)))
            }
        }
    }

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

    /// @dev Returns `x / y`, returning 0 if `y` is zero.
    function _rawDiv(uint256 x, uint256 y) private pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := div(x, y)
        }
    }

    /// @dev Returns `x % y`, returning 0 if `y` is zero.
    function _rawMod(uint256 x, uint256 y) private pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := mod(x, y)
        }
    }
}

/// @notice Library for converting numbers into strings and other string operations.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibString.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/LibString.sol)
///
/// @dev Note:
/// For performance and bytecode compactness, most of the string operations are restricted to
/// byte strings (7-bit ASCII), except where otherwise specified.
/// Usage of byte string operations on charsets with runes spanning two or more bytes
/// can lead to undefined behavior.
library LibString {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                        CUSTOM ERRORS                       */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            if temp {
                mstore(0x00, 0x2194895a) // `HexLengthInsufficient()`.
                revert(0x1c, 0x04)
            }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            value := shl(96, value)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /// @dev Escapes the string to be used within double-quotes in a JSON.
    function escapeJSON(string memory s) internal pure returns (string memory result) {
        result = escapeJSON(s, false);
    }

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

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

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

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

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

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

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

/// @notice Simple single owner authorization mixin.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/auth/Ownable.sol)
///
/// @dev Note:
/// This implementation does NOT auto-initialize the owner to `msg.sender`.
/// You MUST call the `_initializeOwner` in the constructor / initializer.
///
/// While the ownable portion follows
/// [EIP-173](https://eips.ethereum.org/EIPS/eip-173) for compatibility,
/// the nomenclature for the 2-step ownership handover may be unique to this codebase.
abstract contract Ownable {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The caller is not authorized to call the function.
    error Unauthorized();

    /// @dev The `newOwner` cannot be the zero address.
    error NewOwnerIsZeroAddress();

    /// @dev The `pendingOwner` does not have a valid handover request.
    error NoHandoverRequest();

    /// @dev Cannot double-initialize.
    error AlreadyInitialized();

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

    /// @dev The ownership is transferred from `oldOwner` to `newOwner`.
    /// This event is intentionally kept the same as OpenZeppelin's Ownable to be
    /// compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173),
    /// despite it not being as lightweight as a single argument event.
    event OwnershipTransferred(address indexed oldOwner, address indexed newOwner);

    /// @dev An ownership handover to `pendingOwner` has been requested.
    event OwnershipHandoverRequested(address indexed pendingOwner);

    /// @dev The ownership handover to `pendingOwner` has been canceled.
    event OwnershipHandoverCanceled(address indexed pendingOwner);

    /// @dev `keccak256(bytes("OwnershipTransferred(address,address)"))`.
    uint256 private constant _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE =
    0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0;

    /// @dev `keccak256(bytes("OwnershipHandoverRequested(address)"))`.
    uint256 private constant _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE =
    0xdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d;

    /// @dev `keccak256(bytes("OwnershipHandoverCanceled(address)"))`.
    uint256 private constant _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE =
    0xfa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c92;

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

    /// @dev The owner slot is given by:
    /// `bytes32(~uint256(uint32(bytes4(keccak256("_OWNER_SLOT_NOT")))))`.
    /// It is intentionally chosen to be a high value
    /// to avoid collision with lower slots.
    /// The choice of manual storage layout is to enable compatibility
    /// with both regular and upgradeable contracts.
    bytes32 internal constant _OWNER_SLOT =
    0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927;

    /// The ownership handover slot of `newOwner` is given by:
    /// ```
    ///     mstore(0x00, or(shl(96, user), _HANDOVER_SLOT_SEED))
    ///     let handoverSlot := keccak256(0x00, 0x20)
    /// ```
    /// It stores the expiry timestamp of the two-step ownership handover.
    uint256 private constant _HANDOVER_SLOT_SEED = 0x389a75e1;

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

    /// @dev Override to return true to make `_initializeOwner` prevent double-initialization.
    function _guardInitializeOwner() internal pure virtual returns (bool guard) {}

    /// @dev Initializes the owner directly without authorization guard.
    /// This function must be called upon initialization,
    /// regardless of whether the contract is upgradeable or not.
    /// This is to enable generalization to both regular and upgradeable contracts,
    /// and to save gas in case the initial owner is not the caller.
    /// For performance reasons, this function will not check if there
    /// is an existing owner.
    function _initializeOwner(address newOwner) internal virtual {
        if (_guardInitializeOwner()) {
            /// @solidity memory-safe-assembly
            assembly {
                let ownerSlot := _OWNER_SLOT
                if sload(ownerSlot) {
                    mstore(0x00, 0x0dc149f0) // `AlreadyInitialized()`.
                    revert(0x1c, 0x04)
                }
            // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
            // Store the new value.
                sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))
            // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)
            }
        } else {
            /// @solidity memory-safe-assembly
            assembly {
            // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
            // Store the new value.
                sstore(_OWNER_SLOT, newOwner)
            // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)
            }
        }
    }

    /// @dev Sets the owner directly without authorization guard.
    function _setOwner(address newOwner) internal virtual {
        if (_guardInitializeOwner()) {
            /// @solidity memory-safe-assembly
            assembly {
                let ownerSlot := _OWNER_SLOT
            // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
            // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)
            // Store the new value.
                sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))
            }
        } else {
            /// @solidity memory-safe-assembly
            assembly {
                let ownerSlot := _OWNER_SLOT
            // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
            // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)
            // Store the new value.
                sstore(ownerSlot, newOwner)
            }
        }
    }

    /// @dev Throws if the sender is not the owner.
    function _checkOwner() internal view virtual {
        /// @solidity memory-safe-assembly
        assembly {
        // If the caller is not the stored owner, revert.
            if iszero(eq(caller(), sload(_OWNER_SLOT))) {
                mstore(0x00, 0x82b42900) // `Unauthorized()`.
                revert(0x1c, 0x04)
            }
        }
    }

    /// @dev Returns how long a two-step ownership handover is valid for in seconds.
    /// Override to return a different value if needed.
    /// Made internal to conserve bytecode. Wrap it in a public function if needed.
    function _ownershipHandoverValidFor() internal view virtual returns (uint64) {
        return 48 * 3600;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                  PUBLIC UPDATE FUNCTIONS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Allows the owner to transfer the ownership to `newOwner`.
    function transferOwnership(address newOwner) public payable virtual onlyOwner {
        /// @solidity memory-safe-assembly
        assembly {
            if iszero(shl(96, newOwner)) {
                mstore(0x00, 0x7448fbae) // `NewOwnerIsZeroAddress()`.
                revert(0x1c, 0x04)
            }
        }
        _setOwner(newOwner);
    }

    /// @dev Allows the owner to renounce their ownership.
    function renounceOwnership() public payable virtual onlyOwner {
        _setOwner(address(0));
    }

    /// @dev Request a two-step ownership handover to the caller.
    /// The request will automatically expire in 48 hours (172800 seconds) by default.
    function requestOwnershipHandover() public payable virtual {
        unchecked {
            uint256 expires = block.timestamp + _ownershipHandoverValidFor();
        /// @solidity memory-safe-assembly
            assembly {
            // Compute and set the handover slot to `expires`.
                mstore(0x0c, _HANDOVER_SLOT_SEED)
                mstore(0x00, caller())
                sstore(keccak256(0x0c, 0x20), expires)
            // Emit the {OwnershipHandoverRequested} event.
                log2(0, 0, _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE, caller())
            }
        }
    }

    /// @dev Cancels the two-step ownership handover to the caller, if any.
    function cancelOwnershipHandover() public payable virtual {
        /// @solidity memory-safe-assembly
        assembly {
        // Compute and set the handover slot to 0.
            mstore(0x0c, _HANDOVER_SLOT_SEED)
            mstore(0x00, caller())
            sstore(keccak256(0x0c, 0x20), 0)
        // Emit the {OwnershipHandoverCanceled} event.
            log2(0, 0, _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE, caller())
        }
    }

    /// @dev Allows the owner to complete the two-step ownership handover to `pendingOwner`.
    /// Reverts if there is no existing ownership handover requested by `pendingOwner`.
    function completeOwnershipHandover(address pendingOwner) public payable virtual onlyOwner {
        /// @solidity memory-safe-assembly
        assembly {
        // Compute and set the handover slot to 0.
            mstore(0x0c, _HANDOVER_SLOT_SEED)
            mstore(0x00, pendingOwner)
            let handoverSlot := keccak256(0x0c, 0x20)
        // If the handover does not exist, or has expired.
            if gt(timestamp(), sload(handoverSlot)) {
                mstore(0x00, 0x6f5e8818) // `NoHandoverRequest()`.
                revert(0x1c, 0x04)
            }
        // Set the handover slot to 0.
            sstore(handoverSlot, 0)
        }
        _setOwner(pendingOwner);
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                   PUBLIC READ FUNCTIONS                    */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the owner of the contract.
    function owner() public view virtual returns (address result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := sload(_OWNER_SLOT)
        }
    }

    /// @dev Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`.
    function ownershipHandoverExpiresAt(address pendingOwner)
    public
    view
    virtual
    returns (uint256 result)
    {
        /// @solidity memory-safe-assembly
        assembly {
        // Compute the handover slot.
            mstore(0x0c, _HANDOVER_SLOT_SEED)
            mstore(0x00, pendingOwner)
        // Load the handover slot.
            result := sload(keccak256(0x0c, 0x20))
        }
    }

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

    /// @dev Marks a function as only callable by the owner.
    modifier onlyOwner() virtual {
        _checkOwner();
        _;
    }
}


/// @title ERC_YB_NFT
/// @notice ERC_YB_NFT provides an interface for interacting with the
/// NFT tokens in a DN404 implementation.
///
/// @author vectorized.eth (@optimizoor)
/// @author Quit (@0xQuit)
/// @author Michael Amadi (@AmadiMichaels)
/// @author cygaar (@0xCygaar)
/// @author Thomas (@0xjustadev)
/// @author Harrison (@PopPunkOnChain)
///
/// @dev Note:
/// - The ERC721 data is stored in the base DN404 contract.
contract ERC_YB_NFT {
    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                           EVENTS                           */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

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

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

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

    /// @dev The ownership is transferred from `oldOwner` to `newOwner`.
    /// This is for marketplace signaling purposes. This contract has a `pullOwner()`
    /// function that will sync the owner from the base contract.
    event OwnershipTransferred(address indexed oldOwner, address indexed newOwner);

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

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

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

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                        CUSTOM ERRORS                       */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    /// @dev Thrown when a call for an NFT function did not originate
    /// from the base DN404 contract.
    error SenderNotBase();

    /// @dev Thrown when a call for an NFT function did not originate from the deployer.
    error SenderNotDeployer();

    /// @dev Thrown when transferring an NFT to a contract address that
    /// does not implement ERC721Receiver.
    error TransferToNonERC721ReceiverImplementer();

    /// @dev Thrown when linking to the DN404 base contract and the
    /// DN404 supportsInterface check fails or the call reverts.
    error CannotLink();

    /// @dev Thrown when a linkMirrorContract call is received and the
    /// NFT mirror contract has already been linked to a DN404 base contract.
    error AlreadyLinked();

    /// @dev Thrown when retrieving the base DN404 address when a link has not
    /// been established.
    error NotLinked();

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                          STORAGE                           */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    /// @dev Struct contain the NFT mirror contract storage.
    struct DN404NFTStorage {
        address baseERC20;
        address deployer;
        address owner;
    }

    /// @dev Returns a storage pointer for DN404NFTStorage.
    function _getDN404NFTStorage() internal pure virtual returns (DN404NFTStorage storage $) {
        /// @solidity memory-safe-assembly
        assembly {
        // `uint72(bytes9(keccak256("DN404_MIRROR_STORAGE")))`.
            $.slot := 0x3602298b8c10b01230 // Truncate to 9 bytes to reduce bytecode size.
        }
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                        CONSTRUCTOR                         */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    constructor(address deployer) {
        // For non-proxies, we will store the deployer so that only the deployer can
        // link the base contract.
        _getDN404NFTStorage().deployer = deployer;
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                     ERC721 OPERATIONS                      */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    /// @dev Returns the token collection name from the base DN404 contract.
    function name() public view virtual returns (string memory result) {
        return _readString(0x06fdde03, 0); // `symbol()`.
    }

    /// @dev Returns the token collection symbol from the base DN404 contract.
    function symbol() public view virtual returns (string memory result) {
        return _readString(0x95d89b41, 0); // `symbol()`.
    }

    /// @dev Returns the Uniform Resource Identifier (URI) for token `id` from
    /// the base DN404 contract.
    function tokenURI(uint256 id) public view virtual returns (string memory result) {
        return _readString(0xc87b56dd, id); // `tokenURI()`.
    }

    /// @dev Returns the total NFT supply from the base DN404 contract.
    function totalSupply() public view virtual returns (uint256 result) {
        return _readWord(0xe2c79281, 0, 0); // `totalNFTSupply()`.
    }

    /// @dev Returns the number of NFT tokens owned by `nftOwner` from the base DN404 contract.
    ///
    /// Requirements:
    /// - `nftOwner` must not be the zero address.
    function balanceOf(address nftOwner) public view virtual returns (uint256 result) {
        return _readWord(0xf5b100ea, uint160(nftOwner), 0); // `balanceOfNFT(address)`.
    }

    /// @dev Returns the owner of token `id` from the base DN404 contract.
    ///
    /// Requirements:
    /// - Token `id` must exist.
    function ownerOf(uint256 id) public view virtual returns (address result) {
        return address(uint160(_readWord(0x6352211e, id, 0))); // `ownerOf(uint256)`.
    }

    /// @dev Returns the owner of token `id` from the base DN404 contract.
    /// Returns `address(0)` instead of reverting if the token does not exist.
    function ownerAt(uint256 id) public view virtual returns (address result) {
        return address(uint160(_readWord(0x24359879, id, 0))); // `ownerAt(uint256)`.
    }

    /// @dev Sets `spender` as the approved account to manage token `id` in
    /// the base DN404 contract.
    ///
    /// Requirements:
    /// - Token `id` must exist.
    /// - The caller must be the owner of the token,
    ///   or an approved operator for the token owner.
    ///
    /// Emits an {Approval} event.
    function approve(address spender, uint256 id) public virtual {
        address base = baseERC20();
        /// @solidity memory-safe-assembly
        assembly {
            spender := shr(96, shl(96, spender))
            let m := mload(0x40)
            mstore(0x00, 0xd10b6e0c) // `approveNFT(address,uint256,address)`.
            mstore(0x20, spender)
            mstore(0x40, id)
            mstore(0x60, caller())
            if iszero(
                and(
                    gt(returndatasize(), 0x1f),
                    call(gas(), base, callvalue(), 0x1c, 0x64, 0x00, 0x20)
                )
            ) {
                returndatacopy(m, 0x00, returndatasize())
                revert(m, returndatasize())
            }
            mstore(0x40, m) // Restore the free memory pointer.
            mstore(0x60, 0) // Restore the zero pointer.
        // Emit the {Approval} event.
            log4(codesize(), 0x00, _APPROVAL_EVENT_SIGNATURE, shr(96, mload(0x0c)), spender, id)
        }
    }

    /// @dev Returns the account approved to manage token `id` from
    /// the base DN404 contract.
    ///
    /// Requirements:
    /// - Token `id` must exist.
    function getApproved(uint256 id) public view virtual returns (address) {
        return address(uint160(_readWord(0x081812fc, id, 0))); // `getApproved(uint256)`.
    }

    /// @dev Sets whether `operator` is approved to manage the tokens of the caller in
    /// the base DN404 contract.
    ///
    /// Emits an {ApprovalForAll} event.
    function setApprovalForAll(address operator, bool approved) public virtual {
        address base = baseERC20();
        /// @solidity memory-safe-assembly
        assembly {
            operator := shr(96, shl(96, operator))
            let m := mload(0x40)
            mstore(0x00, 0x813500fc) // `setApprovalForAll(address,bool,address)`.
            mstore(0x20, operator)
            mstore(0x40, iszero(iszero(approved)))
            mstore(0x60, caller())
            if iszero(
                and(eq(mload(0x00), 1), call(gas(), base, callvalue(), 0x1c, 0x64, 0x00, 0x20))
            ) {
                returndatacopy(m, 0x00, returndatasize())
                revert(m, returndatasize())
            }
        // Emit the {ApprovalForAll} event.
        // The `approved` value is already at 0x40.
            log3(0x40, 0x20, _APPROVAL_FOR_ALL_EVENT_SIGNATURE, caller(), operator)
            mstore(0x40, m) // Restore the free memory pointer.
            mstore(0x60, 0) // Restore the zero pointer.
        }
    }

    /// @dev Returns whether `operator` is approved to manage the tokens of `nftOwner` from
    /// the base DN404 contract.
    function isApprovedForAll(address nftOwner, address operator)
    public
    view
    virtual
    returns (bool result)
    {
        // `isApprovedForAll(address,address)`.
        return _readWord(0xe985e9c5, uint160(nftOwner), uint160(operator)) != 0;
    }

    /// @dev Transfers token `id` from `from` to `to`.
    ///
    /// Requirements:
    ///
    /// - Token `id` must exist.
    /// - `from` must be the owner of the token.
    /// - `to` cannot be the zero address.
    /// - The caller must be the owner of the token, or be approved to manage the token.
    ///
    /// Emits a {Transfer} event.
    function transferFrom(address from, address to, uint256 id) public virtual {
        address base = baseERC20();
        /// @solidity memory-safe-assembly
        assembly {
            from := shr(96, shl(96, from))
            to := shr(96, shl(96, to))
            let m := mload(0x40)
            mstore(m, 0xe5eb36c8) // `transferFromNFT(address,address,uint256,address)`.
            mstore(add(m, 0x20), from)
            mstore(add(m, 0x40), to)
            mstore(add(m, 0x60), id)
            mstore(add(m, 0x80), caller())
            if iszero(
                and(eq(mload(m), 1), call(gas(), base, callvalue(), add(m, 0x1c), 0x84, m, 0x20))
            ) {
                returndatacopy(m, 0x00, returndatasize())
                revert(m, returndatasize())
            }
        // Emit the {Transfer} event.
            log4(codesize(), 0x00, _TRANSFER_EVENT_SIGNATURE, from, to, id)
        }
    }

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

        if (_hasCode(to)) _checkOnERC721Received(from, to, id, "");
    }

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

        if (_hasCode(to)) _checkOnERC721Received(from, to, id, data);
    }

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

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                  OWNER SYNCING OPERATIONS                  */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    /// @dev Returns the `owner` of the contract, for marketplace signaling purposes.
    function owner() public view virtual returns (address) {
        return _getDN404NFTStorage().owner;
    }

    /// @dev Permissionless function to pull the owner from the base DN404 contract
    /// if it implements ownable, for marketplace signaling purposes.
    function pullOwner() public virtual {
        address newOwner;
        address base = baseERC20();
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, 0x8da5cb5b) // `owner()`.
            if and(gt(returndatasize(), 0x1f), staticcall(gas(), base, 0x1c, 0x04, 0x00, 0x20)) {
                newOwner := shr(96, mload(0x0c))
            }
        }
        DN404NFTStorage storage $ = _getDN404NFTStorage();
        address oldOwner = $.owner;
        if (oldOwner != newOwner) {
            $.owner = newOwner;
            emit OwnershipTransferred(oldOwner, newOwner);
        }
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                     MIRROR OPERATIONS                      */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    /// @dev Returns the address of the base DN404 contract.
    function baseERC20() public view virtual returns (address base) {
        base = _getDN404NFTStorage().baseERC20;
        if (base == address(0)) revert NotLinked();
    }

    /// @dev Fallback modifier to execute calls from the base DN404 contract.
    modifier dn404NFTFallback() virtual {
        DN404NFTStorage storage $ = _getDN404NFTStorage();

        uint256 fnSelector = _calldataload(0x00) >> 224;

        // `logTransfer(uint256[])`.
        if (fnSelector == 0x263c69d6) {
            if (msg.sender != $.baseERC20) revert SenderNotBase();
            /// @solidity memory-safe-assembly
            assembly {
            // When returndatacopy copies 1 or more out-of-bounds bytes, it reverts.
                returndatacopy(0x00, returndatasize(), lt(calldatasize(), 0x20))
                let o := add(0x24, calldataload(0x04)) // Packed logs offset.
                returndatacopy(0x00, returndatasize(), lt(calldatasize(), o))
                let end := add(o, shl(5, calldataload(sub(o, 0x20))))
                returndatacopy(0x00, returndatasize(), lt(calldatasize(), end))

                for {} iszero(eq(o, end)) { o := add(0x20, o) } {
                    let d := calldataload(o) // Entry in the packed logs.
                    let a := shr(96, d) // The address.
                    let b := and(1, d) // Whether it is a burn.
                    log4(
                        codesize(),
                        0x00,
                        _TRANSFER_EVENT_SIGNATURE,
                        mul(a, b), // `from`.
                        mul(a, iszero(b)), // `to`.
                        shr(168, shl(160, d)) // `id`.
                    )
                }
                mstore(0x00, 0x01)
                return(0x00, 0x20)
            }
        }
        // `linkMirrorContract(address)`.
        if (fnSelector == 0x0f4599e5) {
            if ($.deployer != address(0)) {
                if (address(uint160(_calldataload(0x04))) != $.deployer) {
                    revert SenderNotDeployer();
                }
            }
            if ($.baseERC20 != address(0)) revert AlreadyLinked();
            $.baseERC20 = msg.sender;
            /// @solidity memory-safe-assembly
            assembly {
                mstore(0x00, 0x01)
                return(0x00, 0x20)
            }
        }
        _;
    }

    /// @dev Fallback function for calls from base DN404 contract.
    fallback() external payable virtual dn404NFTFallback {}

    receive() external payable virtual {}

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                      PRIVATE HELPERS                       */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    /// @dev Helper to read a string from the base DN404 contract.
    function _readString(uint256 fnSelector, uint256 arg0)
    private
    view
    returns (string memory result)
    {
        address base = baseERC20();
        /// @solidity memory-safe-assembly
        assembly {
            result := mload(0x40)
            mstore(0x00, fnSelector)
            mstore(0x20, arg0)
            if iszero(staticcall(gas(), base, 0x1c, 0x24, 0x00, 0x00)) {
                returndatacopy(result, 0x00, returndatasize())
                revert(result, returndatasize())
            }
            returndatacopy(0x00, 0x00, 0x20) // Copy the offset of the string in returndata.
            returndatacopy(result, mload(0x00), 0x20) // Copy the length of the string.
            returndatacopy(add(result, 0x20), add(mload(0x00), 0x20), mload(result)) // Copy the string.
            mstore(0x40, add(add(result, 0x20), mload(result))) // Allocate memory.
        }
    }

    /// @dev Helper to read a word from the base DN404 contract.
    function _readWord(uint256 fnSelector, uint256 arg0, uint256 arg1)
    private
    view
    returns (uint256 result)
    {
        address base = baseERC20();
        /// @solidity memory-safe-assembly
        assembly {
            let m := mload(0x40)
            mstore(0x00, fnSelector)
            mstore(0x20, arg0)
            mstore(0x40, arg1)
            if iszero(
                and(gt(returndatasize(), 0x1f), staticcall(gas(), base, 0x1c, 0x44, 0x00, 0x20))
            ) {
                returndatacopy(m, 0x00, returndatasize())
                revert(m, returndatasize())
            }
            mstore(0x40, m) // Restore the free memory pointer.
            result := mload(0x00)
        }
    }

    /// @dev Returns the calldata value at `offset`.
    function _calldataload(uint256 offset) private pure returns (uint256 value) {
        /// @solidity memory-safe-assembly
        assembly {
            value := calldataload(offset)
        }
    }

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

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

/// @title DN404
/// @notice DN404 is a hybrid ERC20 and ERC721 implementation that mints
/// and burns NFTs based on an account's ERC20 token balance.
///
/// @author vectorized.eth (@optimizoor)
/// @author Quit (@0xQuit)
/// @author Michael Amadi (@AmadiMichaels)
/// @author cygaar (@0xCygaar)
/// @author Thomas (@0xjustadev)
/// @author Harrison (@PopPunkOnChain)
///
/// @dev Note:
/// - The ERC721 data is stored in this base DN404 contract, however a
///   ERC_YB_NFT contract ***MUST*** be deployed and linked during
///   initialization.
abstract contract ERC_YB {
    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                           EVENTS                           */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

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

    /// @dev Emitted when `amount` tokens is approved by `owner` to be used by `spender`.
    event Approval(address indexed owner, address indexed spender, uint256 amount);

    /// @dev Emitted when `target` sets their skipNFT flag to `status`.
    event SkipNFTSet(address indexed target, bool status);

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

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

    /// @dev `keccak256(bytes("SkipNFTSet(address,bool)"))`.
    uint256 private constant _SKIP_NFT_SET_EVENT_SIGNATURE =
    0xb5a1de456fff688115a4f75380060c23c8532d14ff85f687cc871456d6420393;

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                        CUSTOM ERRORS                       */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    /// @dev Thrown when attempting to double-initialize the contract.
    error DNAlreadyInitialized();

    /// @dev Thrown when attempting to transfer or burn more tokens than sender's balance.
    error InsufficientBalance();

    /// @dev Thrown when a spender attempts to transfer tokens with an insufficient allowance.
    error InsufficientAllowance();

    /// @dev Thrown when minting an amount of tokens that would overflow the max tokens.
    error TotalSupplyOverflow();

    /// @dev The unit cannot be zero.
    error UnitIsZero();

    /// @dev Thrown when the caller for a fallback NFT function is not the mirror contract.
    error SenderNotMirror();

    /// @dev Thrown when attempting to transfer tokens to the zero address.
    error TransferToZeroAddress();

    /// @dev Thrown when the mirror address provided for initialization is the zero address.
    error MirrorAddressIsZero();

    /// @dev Thrown when the link call to the mirror contract reverts.
    error LinkMirrorContractFailed();

    /// @dev Thrown when setting an NFT token approval
    /// and the caller is not the owner or an approved operator.
    error ApprovalCallerNotOwnerNorApproved();

    /// @dev Thrown when transferring an NFT
    /// and the caller is not the owner or an approved operator.
    error TransferCallerNotOwnerNorApproved();

    /// @dev Thrown when transferring an NFT and the from address is not the current owner.
    error TransferFromIncorrectOwner();

    /// @dev Thrown when checking the owner or approved address for a non-existent NFT.
    error TokenDoesNotExist();

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                         CONSTANTS                          */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    /// @dev The flag to denote that the address data is initialized.
    uint8 internal constant _ADDRESS_DATA_INITIALIZED_FLAG = 1 << 0;

    /// @dev The flag to denote that the address should skip NFTs.
    uint8 internal constant _ADDRESS_DATA_SKIP_NFT_FLAG = 1 << 1;

    /// @dev The flag to denote that the address has overridden the default Permit2 allowance.
    uint8 internal constant _ADDRESS_DATA_OVERRIDE_PERMIT2_FLAG = 1 << 2;

    /// @dev The canonical Permit2 address.
    /// For signature-based allowance granting for single transaction ERC20 `transferFrom`.
    /// To enable, override `_givePermit2DefaultInfiniteAllowance()`.
    /// [Github](https://github.com/Uniswap/permit2)
    /// [Etherscan](https://etherscan.io/address/0x000000000022D473030F116dDEE9F6B43aC78BA3)
    address internal constant _PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                          STORAGE                           */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    /// @dev Struct containing an address's token data and settings.
    struct AddressData {
        // Auxiliary data.
        uint88 aux;
        // Flags for `initialized` and `skipNFT`.
        uint8 flags;
        // The alias for the address. Zero means absence of an alias.
        uint32 addressAlias;
        // The number of NFT tokens.
        uint32 ownedLength;
        // The token balance in wei.
        uint96 balance;
    }

    /// @dev A uint32 map in storage.
    struct Uint32Map {
        uint256 spacer;
    }

    /// @dev A bitmap in storage.
    struct Bitmap {
        uint256 spacer;
    }

    /// @dev A struct to wrap a uint256 in storage.
    struct Uint256Ref {
        uint256 value;
    }

    /// @dev A mapping of an address pair to a Uint256Ref.
    struct AddressPairToUint256RefMap {
        uint256 spacer;
    }

    /// @dev Struct containing the base token contract storage.
    struct DN404Storage {
        // Current number of address aliases assigned.
        uint32 numAliases;
        // Next token ID to assign for an NFT mint.
        uint32 nextTokenId;
        // Total number of IDs in the burned pool.
        uint32 burnedPoolSize;
        // Total supply of minted NFTs.
        uint32 totalNFTSupply;
        // Total supply of tokens.
        uint96 totalSupply;
        // Address of the NFT mirror contract.
        address mirrorERC721;
        // Mapping of a user alias number to their address.
        mapping(uint32 => address) aliasToAddress;
        // Mapping of user operator approvals for NFTs.
        AddressPairToUint256RefMap operatorApprovals;
        // Mapping of NFT token approvals to approved operators.
        mapping(uint256 => address) nftApprovals;
        // Bitmap of whether an non-zero NFT approval may exist.
        Bitmap mayHaveNFTApproval;
        // Mapping of user allowances for token spenders.
        AddressPairToUint256RefMap allowance;
        // Mapping of NFT IDs owned by an address.
        mapping(address => Uint32Map) owned;
        // The pool of burned NFT IDs.
        Uint32Map burnedPool;
        // Even indices: owner aliases. Odd indices: owned indices.
        Uint32Map oo;
        // Mapping of user account AddressData.
        mapping(address => AddressData) addressData;
    }

    /// @dev Returns a storage pointer for DN404Storage.
    function _getDN404Storage() internal pure virtual returns (DN404Storage storage $) {
        /// @solidity memory-safe-assembly
        assembly {
        // `uint72(bytes9(keccak256("DN404_STORAGE")))`.
            $.slot := 0xa20d6e21d0e5255308 // Truncate to 9 bytes to reduce bytecode size.
        }
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                         INITIALIZER                        */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    /// @dev Initializes the DN404 contract with an
    /// `initialTokenSupply`, `initialTokenOwner` and `mirror` NFT contract address.
    function _initializeDN404(
        uint256 initialTokenSupply,
        address initialSupplyOwner,
        address mirror
    ) internal virtual {
        DN404Storage storage $ = _getDN404Storage();

        if ($.nextTokenId != 0) revert DNAlreadyInitialized();

        if (mirror == address(0)) revert MirrorAddressIsZero();

        /// @solidity memory-safe-assembly
        assembly {
        // Make the call to link the mirror contract.
            mstore(0x00, 0x0f4599e5) // `linkMirrorContract(address)`.
            mstore(0x20, caller())
            if iszero(and(eq(mload(0x00), 1), call(gas(), mirror, 0, 0x1c, 0x24, 0x00, 0x20))) {
                mstore(0x00, 0xd125259c) // `LinkMirrorContractFailed()`.
                revert(0x1c, 0x04)
            }
        }

        $.nextTokenId = 1;
        $.mirrorERC721 = mirror;

        if (_unit() == 0) revert UnitIsZero();

        if (initialTokenSupply != 0) {
            if (initialSupplyOwner == address(0)) revert TransferToZeroAddress();
            if (_totalSupplyOverflows(initialTokenSupply)) revert TotalSupplyOverflow();

            $.totalSupply = uint96(initialTokenSupply);
            AddressData storage initialOwnerAddressData = _addressData(initialSupplyOwner);
            initialOwnerAddressData.balance = uint96(initialTokenSupply);

            /// @solidity memory-safe-assembly
            assembly {
            // Emit the {Transfer} event.
                mstore(0x00, initialTokenSupply)
                log3(0x00, 0x20, _TRANSFER_EVENT_SIGNATURE, 0, shr(96, shl(96, initialSupplyOwner)))
            }

            _setSkipNFT(initialSupplyOwner, true);
        }
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*               BASE UNIT FUNCTION TO OVERRIDE               */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    /// @dev Amount of token balance that is equal to one NFT.
    function _unit() internal view virtual returns (uint256) {
        return 10 ** 18;
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*               METADATA FUNCTIONS TO OVERRIDE               */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

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

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

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

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                      ERC20 OPERATIONS                      */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    /// @dev Returns the decimals places of the token. Always 18.
    function decimals() public pure returns (uint8) {
        return 18;
    }

    /// @dev Returns the amount of tokens in existence.
    function totalSupply() public view virtual returns (uint256) {
        return uint256(_getDN404Storage().totalSupply);
    }

    /// @dev Returns the amount of tokens owned by `owner`.
    function balanceOf(address owner) public view virtual returns (uint256) {
        return _getDN404Storage().addressData[owner].balance;
    }

    /// @dev Returns the amount of tokens that `spender` can spend on behalf of `owner`.
    function allowance(address owner, address spender) public view returns (uint256) {
        if (_givePermit2DefaultInfiniteAllowance() && spender == _PERMIT2) {
            uint8 flags = _getDN404Storage().addressData[owner].flags;
            if (flags & _ADDRESS_DATA_OVERRIDE_PERMIT2_FLAG == 0) return type(uint256).max;
        }
        return _ref(_getDN404Storage().allowance, owner, spender).value;
    }

    /// @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
    ///
    /// Emits a {Approval} event.
    function approve(address spender, uint256 amount) public virtual returns (bool) {
        _approve(msg.sender, spender, amount);
        return true;
    }

    /// @dev Transfer `amount` tokens from the caller to `to`.
    ///
    /// Will burn sender NFTs if balance after transfer is less than
    /// the amount required to support the current NFT balance.
    ///
    /// Will mint NFTs to `to` if the recipient's new balance supports
    /// additional NFTs ***AND*** the `to` address's skipNFT flag is
    /// set to false.
    ///
    /// Requirements:
    /// - `from` must at least have `amount`.
    ///
    /// Emits a {Transfer} event.
    function transfer(address to, uint256 amount) public virtual returns (bool) {
        _transfer(msg.sender, to, amount);
        return true;
    }

    /// @dev Transfers `amount` tokens from `from` to `to`.
    ///
    /// Note: Does not update the allowance if it is the maximum uint256 value.
    ///
    /// Will burn sender NFTs if balance after transfer is less than
    /// the amount required to support the current NFT balance.
    ///
    /// Will mint NFTs to `to` if the recipient's new balance supports
    /// additional NFTs ***AND*** the `to` address's skipNFT flag is
    /// set to false.
    ///
    /// Requirements:
    /// - `from` must at least have `amount`.
    /// - The caller must have at least `amount` of allowance to transfer the tokens of `from`.
    ///
    /// Emits a {Transfer} event.
    function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) {
        Uint256Ref storage a = _ref(_getDN404Storage().allowance, from, msg.sender);

        uint256 allowed = _givePermit2DefaultInfiniteAllowance() && msg.sender == _PERMIT2
        && (_getDN404Storage().addressData[from].flags & _ADDRESS_DATA_OVERRIDE_PERMIT2_FLAG) == 0
            ? type(uint256).max
            : a.value;

        if (allowed != type(uint256).max) {
            if (amount > allowed) revert InsufficientAllowance();
            unchecked {
                a.value = allowed - amount;
            }
        }
        _transfer(from, to, amount);
        return true;
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                          PERMIT2                           */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    /// @dev Whether Permit2 has infinite allowances by default for all owners.
    /// For signature-based allowance granting for single transaction ERC20 `transferFrom`.
    /// To enable, override this function to return true.
    function _givePermit2DefaultInfiniteAllowance() internal view virtual returns (bool) {
        return false;
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                  INTERNAL MINT FUNCTIONS                   */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    /// @dev Mints `amount` tokens to `to`, increasing the total supply.
    ///
    /// Will mint NFTs to `to` if the recipient's new balance supports
    /// additional NFTs ***AND*** the `to` address's skipNFT flag is
    /// set to false.
    ///
    /// Emits a {Transfer} event.
    function _mint(address to, uint256 amount) internal virtual {
        if (to == address(0)) revert TransferToZeroAddress();

        DN404Storage storage $ = _getDN404Storage();

        AddressData storage toAddressData = _addressData(to);

        unchecked {
            uint256 maxNFTId;
            {
                uint256 totalSupply_ = uint256($.totalSupply) + amount;
                $.totalSupply = uint96(totalSupply_);
                uint256 overflows = _toUint(_totalSupplyOverflows(totalSupply_));
                if (overflows | _toUint(totalSupply_ < amount) != 0) revert TotalSupplyOverflow();
                maxNFTId = totalSupply_ / _unit();
            }
            uint256 toEnd;
            {
                uint256 toBalance = uint256(toAddressData.balance) + amount;
                toAddressData.balance = uint96(toBalance);
                toEnd = toBalance / _unit();
            }
            if (toAddressData.flags & _ADDRESS_DATA_SKIP_NFT_FLAG == 0) {
                Uint32Map storage toOwned = $.owned[to];
                Uint32Map storage oo = $.oo;
                uint256 toIndex = toAddressData.ownedLength;
                _PackedLogs memory packedLogs = _packedLogsMalloc(_zeroFloorSub(toEnd, toIndex));

                if (packedLogs.logs.length != 0) {
                    _packedLogsSet(packedLogs, to, 0);
                    uint256 burnedPoolSize = $.burnedPoolSize;
                    uint256 nextTokenId = $.nextTokenId;
                    uint32 toAlias = _registerAndResolveAlias(toAddressData, to);
                    $.totalNFTSupply += uint32(packedLogs.logs.length);
                    toAddressData.ownedLength = uint32(toEnd);
                    // Mint loop.
                    do {
                        uint256 id;
                        if (burnedPoolSize != 0) {
                            id = _get($.burnedPool, --burnedPoolSize);
                        } else {
                            id = nextTokenId;
                            while (_get(oo, _ownershipIndex(id)) != 0) {
                                id = _wrapNFTId(id + 1, maxNFTId);
                            }
                            nextTokenId = _wrapNFTId(id + 1, maxNFTId);
                        }
                        _set(toOwned, toIndex, uint32(id));
                        _setOwnerAliasAndOwnedIndex(oo, id, toAlias, uint32(toIndex++));
                        _packedLogsAppend(packedLogs, id);
                    } while (toIndex != toEnd);

                    // Leave some spacing between minted batches for better open addressing.
                    $.nextTokenId = uint32(_wrapNFTId(nextTokenId + 7, maxNFTId));
                    $.burnedPoolSize = uint32(burnedPoolSize);
                    _packedLogsSend(packedLogs, $.mirrorERC721);
                }
            }
        }
        /// @solidity memory-safe-assembly
        assembly {
        // Emit the {Transfer} event.
            mstore(0x00, amount)
            log3(0x00, 0x20, _TRANSFER_EVENT_SIGNATURE, 0, shr(96, shl(96, to)))
        }
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                  INTERNAL BURN FUNCTIONS                   */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    /// @dev Burns `amount` tokens from `from`, reducing the total supply.
    ///
    /// Will burn sender NFTs if balance after transfer is less than
    /// the amount required to support the current NFT balance.
    ///
    /// Emits a {Transfer} event.
    function _burn(address from, uint256 amount) internal virtual {
        DN404Storage storage $ = _getDN404Storage();

        AddressData storage fromAddressData = _addressData(from);

        uint256 fromBalance = fromAddressData.balance;
        if (amount > fromBalance) revert InsufficientBalance();

        unchecked {
            fromAddressData.balance = uint96(fromBalance -= amount);
            uint256 totalSupply_ = uint256($.totalSupply) - amount;
            $.totalSupply = uint96(totalSupply_);

            Uint32Map storage fromOwned = $.owned[from];
            uint256 fromIndex = fromAddressData.ownedLength;
            uint256 numNFTBurns = _zeroFloorSub(fromIndex, fromBalance / _unit());

            if (numNFTBurns != 0) {
                _PackedLogs memory packedLogs = _packedLogsMalloc(numNFTBurns);
                _packedLogsSet(packedLogs, from, 1);
                uint256 totalNFTSupply = uint256($.totalNFTSupply) - numNFTBurns;
                $.totalNFTSupply = uint32(totalNFTSupply);
                bool addToBurnedPool = _addToBurnedPool(totalNFTSupply, totalSupply_);

                Uint32Map storage oo = $.oo;
                uint256 fromEnd = fromIndex - numNFTBurns;
                fromAddressData.ownedLength = uint32(fromEnd);
                uint256 burnedPoolSize = $.burnedPoolSize;
                // Burn loop.
                do {
                    uint256 id = _get(fromOwned, --fromIndex);
                    _setOwnerAliasAndOwnedIndex(oo, id, 0, 0);
                    _packedLogsAppend(packedLogs, id);
                    if (addToBurnedPool) {
                        _set($.burnedPool, burnedPoolSize++, uint32(id));
                    }
                    if (_get($.mayHaveNFTApproval, id)) {
                        _set($.mayHaveNFTApproval, id, false);
                        delete $.nftApprovals[id];
                    }
                } while (fromIndex != fromEnd);

                $.burnedPoolSize = uint32(burnedPoolSize);
                _packedLogsSend(packedLogs, $.mirrorERC721);
            }
        }
        /// @solidity memory-safe-assembly
        assembly {
        // Emit the {Transfer} event.
            mstore(0x00, amount)
            log3(0x00, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, shl(96, from)), 0)
        }
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                INTERNAL TRANSFER FUNCTIONS                 */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    /// @dev Moves `amount` of tokens from `from` to `to`.
    ///
    /// Will burn sender NFTs if balance after transfer is less than
    /// the amount required to support the current NFT balance.
    ///
    /// Will mint NFTs to `to` if the recipient's new balance supports
    /// additional NFTs ***AND*** the `to` address's skipNFT flag is
    /// set to false.
    ///
    /// Emits a {Transfer} event.
    function _transfer(address from, address to, uint256 amount) internal virtual {
        if (to == address(0)) revert TransferToZeroAddress();

        DN404Storage storage $ = _getDN404Storage();

        AddressData storage fromAddressData = _addressData(from);
        AddressData storage toAddressData = _addressData(to);

        _TransferTemps memory t;
        t.fromOwnedLength = fromAddressData.ownedLength;
        t.toOwnedLength = toAddressData.ownedLength;
        t.totalSupply = $.totalSupply;

        if (amount > (t.fromBalance = fromAddressData.balance)) revert InsufficientBalance();

        unchecked {
            fromAddressData.balance = uint96(t.fromBalance -= amount);
            toAddressData.balance = uint96(t.toBalance = uint256(toAddressData.balance) + amount);

            t.numNFTBurns = _zeroFloorSub(t.fromOwnedLength, t.fromBalance / _unit());

            if (toAddressData.flags & _ADDRESS_DATA_SKIP_NFT_FLAG == 0) {
                if (from == to) t.toOwnedLength = t.fromOwnedLength - t.numNFTBurns;
                t.numNFTMints = _zeroFloorSub(t.toBalance / _unit(), t.toOwnedLength);
            }

            t.totalNFTSupply = uint256($.totalNFTSupply) + t.numNFTMints - t.numNFTBurns;
            $.totalNFTSupply = uint32(t.totalNFTSupply);

            _PackedLogs memory packedLogs = _packedLogsMalloc(t.numNFTBurns + t.numNFTMints);
            Uint32Map storage oo = $.oo;

            uint256 burnedPoolSize = $.burnedPoolSize;
            if (t.numNFTBurns != 0) {
                _packedLogsSet(packedLogs, from, 1);
                bool addToBurnedPool = _addToBurnedPool(t.totalNFTSupply, t.totalSupply);
                Uint32Map storage fromOwned = $.owned[from];
                uint256 fromIndex = t.fromOwnedLength;
                uint256 fromEnd = fromIndex - t.numNFTBurns;
                fromAddressData.ownedLength = uint32(fromEnd);
                // Burn loop.
                do {
                    uint256 id = _get(fromOwned, --fromIndex);
                    _setOwnerAliasAndOwnedIndex(oo, id, 0, 0);
                    _packedLogsAppend(packedLogs, id);
                    if (addToBurnedPool) {
                        _set($.burnedPool, burnedPoolSize++, uint32(id));
                    }
                    if (_get($.mayHaveNFTApproval, id)) {
                        _set($.mayHaveNFTApproval, id, false);
                        delete $.nftApprovals[id];
                    }
                } while (fromIndex != fromEnd);
            }

            if (t.numNFTMints != 0) {
                _packedLogsSet(packedLogs, to, 0);
                uint256 nextTokenId = $.nextTokenId;
                Uint32Map storage toOwned = $.owned[to];
                uint256 toIndex = t.toOwnedLength;
                uint256 toEnd = toIndex + t.numNFTMints;
                uint32 toAlias = _registerAndResolveAlias(toAddressData, to);
                uint256 maxNFTId = t.totalSupply / _unit();
                toAddressData.ownedLength = uint32(toEnd);
                // Mint loop.
                do {
                    uint256 id;
                    if (burnedPoolSize != 0) {
                        id = _get($.burnedPool, --burnedPoolSize);
                    } else {
                        id = nextTokenId;
                        while (_get(oo, _ownershipIndex(id)) != 0) {
                            id = _wrapNFTId(id + 1, maxNFTId);
                        }
                        nextTokenId = _wrapNFTId(id + 1, maxNFTId);
                    }
                    _set(toOwned, toIndex, uint32(id));
                    _setOwnerAliasAndOwnedIndex(oo, id, toAlias, uint32(toIndex++));
                    _packedLogsAppend(packedLogs, id);
                } while (toIndex != toEnd);

                // Leave some spacing between minted batches for better open addressing.
                $.nextTokenId = uint32(_wrapNFTId(nextTokenId + 7, maxNFTId));
            }

            if (packedLogs.logs.length != 0) {
                $.burnedPoolSize = uint32(burnedPoolSize);
                _packedLogsSend(packedLogs, $.mirrorERC721);
            }
        }
        /// @solidity memory-safe-assembly
        assembly {
        // Emit the {Transfer} event.
            mstore(0x00, amount)
        // forgefmt: disable-next-item
            log3(0x00, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, shl(96, from)), shr(96, shl(96, to)))
        }
    }

    /// @dev Returns if burns should be added to the burn pool.
    function _addToBurnedPool(uint256 totalNFTSupplyAfterBurn, uint256 totalSupplyAfterBurn)
    internal
    view
    virtual
    returns (bool)
    {
        // Add to burned pool if the load factor > 50%, and collection is not small.
        uint256 thres = (totalSupplyAfterBurn / _unit()) >> 1;
        return _toUint(totalNFTSupplyAfterBurn > thres) & _toUint(thres > 128) != 0;
    }

    /// @dev Transfers token `id` from `from` to `to`.
    ///
    /// Requirements:
    ///
    /// - Call must originate from the mirror contract.
    /// - Token `id` must exist.
    /// - `from` must be the owner of the token.
    /// - `to` cannot be the zero address.
    ///   `msgSender` must be the owner of the token, or be approved to manage the token.
    ///
    /// Emits a {Transfer} event.
    function _transferFromNFT(address from, address to, uint256 id, address msgSender)
    internal
    virtual
    {
        DN404Storage storage $ = _getDN404Storage();

        if (to == address(0)) revert TransferToZeroAddress();

        Uint32Map storage oo = $.oo;

        if (from != $.aliasToAddress[_get(oo, _ownershipIndex(id))]) {
            revert TransferFromIncorrectOwner();
        }

        if (msgSender != from) {
            if (_ref($.operatorApprovals, from, msgSender).value == 0) {
                if (msgSender != $.nftApprovals[id]) {
                    revert TransferCallerNotOwnerNorApproved();
                }
            }
        }

        AddressData storage fromAddressData = _addressData(from);
        AddressData storage toAddressData = _addressData(to);

        uint256 unit = _unit();

        unchecked {
            {
                uint256 fromBalance = fromAddressData.balance;
                if (unit > fromBalance) revert InsufficientBalance();
                fromAddressData.balance = uint96(fromBalance - unit);
                toAddressData.balance += uint96(unit);
            }
            mapping(address => Uint32Map) storage owned = $.owned;
            Uint32Map storage fromOwned = owned[from];

            if (_get($.mayHaveNFTApproval, id)) {
                _set($.mayHaveNFTApproval, id, false);
                delete $.nftApprovals[id];
            }

            {
                uint32 updatedId = _get(fromOwned, --fromAddressData.ownedLength);
                uint32 i = _get(oo, _ownedIndex(id));
                _set(fromOwned, i, updatedId);
                _set(oo, _ownedIndex(updatedId), i);
            }
            uint32 n = toAddressData.ownedLength++;
            _set(owned[to], n, uint32(id));
            _setOwnerAliasAndOwnedIndex(oo, id, _registerAndResolveAlias(toAddressData, to), n);
        }

        /// @solidity memory-safe-assembly
        assembly {
        // Emit the {Transfer} event.
            mstore(0x00, unit)
        // forgefmt: disable-next-item
            log3(0x00, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, shl(96, from)), shr(96, shl(96, to)))
        }
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                 INTERNAL APPROVE FUNCTIONS                 */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    /// @dev Sets `amount` as the allowance of `spender` over the tokens of `owner`.
    ///
    /// Emits a {Approval} event.
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        if (_givePermit2DefaultInfiniteAllowance() && spender == _PERMIT2) {
            _getDN404Storage().addressData[owner].flags |= _ADDRESS_DATA_OVERRIDE_PERMIT2_FLAG;
        }
        _ref(_getDN404Storage().allowance, owner, spender).value = amount;
        /// @solidity memory-safe-assembly
        assembly {
        // Emit the {Approval} event.
            mstore(0x00, amount)
        // forgefmt: disable-next-item
            log3(0x00, 0x20, _APPROVAL_EVENT_SIGNATURE, shr(96, shl(96, owner)), shr(96, shl(96, spender)))
        }
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                 DATA HITCHHIKING FUNCTIONS                 */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    /// @dev Returns the auxiliary data for `owner`.
    /// Minting, transferring, burning the tokens of `owner` will not change the auxiliary data.
    /// Auxiliary data can be set for any address, even if it does not have any tokens.
    function _getAux(address owner) internal view virtual returns (uint88) {
        return _getDN404Storage().addressData[owner].aux;
    }

    /// @dev Set the auxiliary data for `owner` to `value`.
    /// Minting, transferring, burning the tokens of `owner` will not change the auxiliary data.
    /// Auxiliary data can be set for any address, even if it does not have any tokens.
    function _setAux(address owner, uint88 value) internal virtual {
        _getDN404Storage().addressData[owner].aux = value;
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                     SKIP NFT FUNCTIONS                     */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    /// @dev Returns true if minting and transferring ERC20s to `owner` will skip minting NFTs.
    /// Returns false otherwise.
    function getSkipNFT(address owner) public view virtual returns (bool) {
        AddressData storage d = _getDN404Storage().addressData[owner];
        if (d.flags & _ADDRESS_DATA_INITIALIZED_FLAG == 0) return _hasCode(owner);
        return d.flags & _ADDRESS_DATA_SKIP_NFT_FLAG != 0;
    }

    /// @dev Sets the caller's skipNFT flag to `skipNFT`. Returns true.
    ///
    /// Emits a {SkipNFTSet} event.
    function setSkipNFT(bool skipNFT) public virtual returns (bool) {
        _setSkipNFT(msg.sender, skipNFT);
        return true;
    }

    /// @dev Internal function to set account `owner` skipNFT flag to `state`
    ///
    /// Initializes account `owner` AddressData if it is not currently initialized.
    ///
    /// Emits a {SkipNFTSet} event.
    function _setSkipNFT(address owner, bool state) internal virtual {
        AddressData storage d = _addressData(owner);
        if ((d.flags & _ADDRESS_DATA_SKIP_NFT_FLAG != 0) != state) {
            d.flags ^= _ADDRESS_DATA_SKIP_NFT_FLAG;
        }
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, iszero(iszero(state)))
            log2(0x00, 0x20, _SKIP_NFT_SET_EVENT_SIGNATURE, shr(96, shl(96, owner)))
        }
    }

    /// @dev Returns a storage data pointer for account `owner` AddressData
    ///
    /// Initializes account `owner` AddressData if it is not currently initialized.
    function _addressData(address owner) internal virtual returns (AddressData storage d) {
        d = _getDN404Storage().addressData[owner];
        unchecked {
            if (d.flags & _ADDRESS_DATA_INITIALIZED_FLAG == 0) {
                uint256 skipNFT = (_toUint(_hasCode(owner)) * _ADDRESS_DATA_SKIP_NFT_FLAG);
                d.flags = uint8(skipNFT | _ADDRESS_DATA_INITIALIZED_FLAG);
            }
        }
    }

    /// @dev Returns the `addressAlias` of account `to`.
    ///
    /// Assigns and registers the next alias if `to` alias was not previously registered.
    function _registerAndResolveAlias(AddressData storage toAddressData, address to)
    internal
    virtual
    returns (uint32 addressAlias)
    {
        DN404Storage storage $ = _getDN404Storage();
        addressAlias = toAddressData.addressAlias;
        if (addressAlias == 0) {
            unchecked {
                addressAlias = ++$.numAliases;
            }
            toAddressData.addressAlias = addressAlias;
            $.aliasToAddress[addressAlias] = to;
            if (addressAlias == 0) revert(); // Overflow.
        }
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                     MIRROR OPERATIONS                      */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    /// @dev Returns the address of the mirror NFT contract.
    function mirrorERC721() public view virtual returns (address) {
        return _getDN404Storage().mirrorERC721;
    }

    /// @dev Returns the total NFT supply.
    function _totalNFTSupply() internal view virtual returns (uint256) {
        return _getDN404Storage().totalNFTSupply;
    }

    /// @dev Returns `owner` NFT balance.
    function _balanceOfNFT(address owner) internal view virtual returns (uint256) {
        return _getDN404Storage().addressData[owner].ownedLength;
    }

    /// @dev Returns the owner of token `id`.
    /// Returns the zero address instead of reverting if the token does not exist.
    function _ownerAt(uint256 id) internal view virtual returns (address) {
        DN404Storage storage $ = _getDN404Storage();
        return $.aliasToAddress[_get($.oo, _ownershipIndex(id))];
    }

    /// @dev Returns the owner of token `id`.
    ///
    /// Requirements:
    /// - Token `id` must exist.
    function _ownerOf(uint256 id) internal view virtual returns (address) {
        if (!_exists(id)) revert TokenDoesNotExist();
        return _ownerAt(id);
    }

    /// @dev Returns if token `id` exists.
    function _exists(uint256 id) internal view virtual returns (bool) {
        return _ownerAt(id) != address(0);
    }

    /// @dev Returns the account approved to manage token `id`.
    ///
    /// Requirements:
    /// - Token `id` must exist.
    function _getApproved(uint256 id) internal view virtual returns (address) {
        if (!_exists(id)) revert TokenDoesNotExist();
        return _getDN404Storage().nftApprovals[id];
    }

    /// @dev Sets `spender` as the approved account to manage token `id`, using `msgSender`.
    ///
    /// Requirements:
    /// - `msgSender` must be the owner or an approved operator for the token owner.
    function _approveNFT(address spender, uint256 id, address msgSender)
    internal
    virtual
    returns (address owner)
    {
        DN404Storage storage $ = _getDN404Storage();

        owner = $.aliasToAddress[_get($.oo, _ownershipIndex(id))];

        if (msgSender != owner) {
            if (_ref($.operatorApprovals, owner, msgSender).value == 0) {
                revert ApprovalCallerNotOwnerNorApproved();
            }
        }

        $.nftApprovals[id] = spender;
        _set($.mayHaveNFTApproval, id, spender != address(0));
    }

    /// @dev Approve or remove the `operator` as an operator for `msgSender`,
    /// without authorization checks.
    function _setApprovalForAll(address operator, bool approved, address msgSender)
    internal
    virtual
    {
        _ref(_getDN404Storage().operatorApprovals, msgSender, operator).value = _toUint(approved);
    }

    /// @dev Fallback modifier to dispatch calls from the mirror NFT contract
    /// to internal functions in this contract.
    modifier dn404Fallback() virtual {
        DN404Storage storage $ = _getDN404Storage();

        uint256 fnSelector = _calldataload(0x00) >> 224;

        // `transferFromNFT(address,address,uint256,address)`.
        if (fnSelector == 0xe5eb36c8) {
            if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
            if (msg.data.length < 0x84) revert();

            address from = address(uint160(_calldataload(0x04)));
            address to = address(uint160(_calldataload(0x24)));
            uint256 id = _calldataload(0x44);
            address msgSender = address(uint160(_calldataload(0x64)));

            _transferFromNFT(from, to, id, msgSender);
            _return(1);
        }
        // `setApprovalForAll(address,bool,address)`.
        if (fnSelector == 0x813500fc) {
            if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
            if (msg.data.length < 0x64) revert();

            address spender = address(uint160(_calldataload(0x04)));
            bool status = _calldataload(0x24) != 0;
            address msgSender = address(uint160(_calldataload(0x44)));

            _setApprovalForAll(spender, status, msgSender);
            _return(1);
        }
        // `isApprovedForAll(address,address)`.
        if (fnSelector == 0xe985e9c5) {
            if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
            if (msg.data.length < 0x44) revert();

            address owner = address(uint160(_calldataload(0x04)));
            address operator = address(uint160(_calldataload(0x24)));

            _return(_ref($.operatorApprovals, owner, operator).value);
        }
        // `ownerOf(uint256)`.
        if (fnSelector == 0x6352211e) {
            if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
            if (msg.data.length < 0x24) revert();

            uint256 id = _calldataload(0x04);

            _return(uint160(_ownerOf(id)));
        }
        // `ownerAt(uint256)`.
        if (fnSelector == 0x24359879) {
            if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
            if (msg.data.length < 0x24) revert();

            uint256 id = _calldataload(0x04);

            _return(uint160(_ownerAt(id)));
        }
        // `approveNFT(address,uint256,address)`.
        if (fnSelector == 0xd10b6e0c) {
            if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
            if (msg.data.length < 0x64) revert();

            address spender = address(uint160(_calldataload(0x04)));
            uint256 id = _calldataload(0x24);
            address msgSender = address(uint160(_calldataload(0x44)));

            _return(uint160(_approveNFT(spender, id, msgSender)));
        }
        // `getApproved(uint256)`.
        if (fnSelector == 0x081812fc) {
            if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
            if (msg.data.length < 0x24) revert();

            uint256 id = _calldataload(0x04);

            _return(uint160(_getApproved(id)));
        }
        // `balanceOfNFT(address)`.
        if (fnSelector == 0xf5b100ea) {
            if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
            if (msg.data.length < 0x24) revert();

            address owner = address(uint160(_calldataload(0x04)));

            _return(_balanceOfNFT(owner));
        }
        // `totalNFTSupply()`.
        if (fnSelector == 0xe2c79281) {
            if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
            if (msg.data.length < 0x04) revert();

            _return(_totalNFTSupply());
        }
        // `implementsDN404()`.
        if (fnSelector == 0xb7a94eb8) {
            _return(1);
        }
        _;
    }

    /// @dev Fallback function for calls from mirror NFT contract.
    fallback() external payable virtual dn404Fallback {}

    receive() external payable virtual {}

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                 INTERNAL / PRIVATE HELPERS                 */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    /// @dev Returns `(i - 1) << 1`.
    function _ownershipIndex(uint256 i) internal pure returns (uint256) {
        unchecked {
            return (i - 1) << 1; // Minus 1 as token IDs start from 1.
        }
    }

    /// @dev Returns `((i - 1) << 1) + 1`.
    function _ownedIndex(uint256 i) internal pure returns (uint256) {
        unchecked {
            return ((i - 1) << 1) + 1; // Minus 1 as token IDs start from 1.
        }
    }

    /// @dev Returns the uint32 value at `index` in `map`.
    function _get(Uint32Map storage map, uint256 index) internal view returns (uint32 result) {
        /// @solidity memory-safe-assembly
        assembly {
            let s := add(shl(96, map.slot), shr(3, index)) // Storage slot.
            result := and(0xffffffff, shr(shl(5, and(index, 7)), sload(s)))
        }
    }

    /// @dev Updates the uint32 value at `index` in `map`.
    function _set(Uint32Map storage map, uint256 index, uint32 value) internal {
        /// @solidity memory-safe-assembly
        assembly {
            let s := add(shl(96, map.slot), shr(3, index)) // Storage slot.
            let o := shl(5, and(index, 7)) // Storage slot offset (bits).
            let v := sload(s) // Storage slot value.
            let m := 0xffffffff // Value mask.
            sstore(s, xor(v, shl(o, and(m, xor(shr(o, v), value)))))
        }
    }

    /// @dev Sets the owner alias and the owned index together.
    function _setOwnerAliasAndOwnedIndex(
        Uint32Map storage map,
        uint256 id,
        uint32 ownership,
        uint32 ownedIndex
    ) internal {
        /// @solidity memory-safe-assembly
        assembly {
            let i := sub(id, 1) // Index of the uint64 combined value.
            let s := add(shl(96, map.slot), shr(2, i)) // Storage slot.
            let o := shl(6, and(i, 3)) // Storage slot offset (bits).
            let v := sload(s) // Storage slot value.
            let m := 0xffffffffffffffff // Value mask.
            let combined := or(shl(32, ownedIndex), and(0xffffffff, ownership))
            sstore(s, xor(v, shl(o, and(m, xor(shr(o, v), combined)))))
        }
    }

    /// @dev Returns the boolean value of the bit at `index` in `bitmap`.
    function _get(Bitmap storage bitmap, uint256 index) internal view returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            let s := add(shl(96, bitmap.slot), shr(8, index)) // Storage slot.
            result := and(1, shr(and(0xff, index), sload(s)))
        }
    }

    /// @dev Updates the bit at `index` in `bitmap` to `value`.
    function _set(Bitmap storage bitmap, uint256 index, bool value) internal {
        /// @solidity memory-safe-assembly
        assembly {
            let s := add(shl(96, bitmap.slot), shr(8, index)) // Storage slot.
            let o := and(0xff, index) // Storage slot offset (bits).
            sstore(s, or(and(sload(s), not(shl(o, 1))), shl(o, iszero(iszero(value)))))
        }
    }

    /// @dev Returns a storage reference to the value at (`a0`, `a1`) in `map`.
    function _ref(AddressPairToUint256RefMap storage map, address a0, address a1)
    internal
    pure
    returns (Uint256Ref storage ref)
    {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x28, a1)
            mstore(0x14, a0)
            mstore(0x00, map.slot)
            ref.slot := keccak256(0x00, 0x48)
        // Clear the part of the free memory pointer that was overwritten.
            mstore(0x28, 0x00)
        }
    }

    /// @dev Wraps the NFT ID.
    function _wrapNFTId(uint256 id, uint256 maxNFTId) internal pure returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := or(mul(iszero(gt(id, maxNFTId)), id), gt(id, maxNFTId))
        }
    }

    /// @dev Returns whether `amount` is a valid `totalSupply`.
    function _totalSupplyOverflows(uint256 amount) internal view returns (bool) {
        unchecked {
            return _toUint(amount > type(uint96).max)
            | _toUint(amount / _unit() > type(uint32).max - 1) != 0;
        }
    }

    /// @dev Returns `max(0, x - y)`.
    function _zeroFloorSub(uint256 x, uint256 y) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := mul(gt(x, y), sub(x, y))
        }
    }

    /// @dev Returns `b ? 1 : 0`.
    function _toUint(bool b) internal pure returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := iszero(iszero(b))
        }
    }

    /// @dev Struct containing packed log data for {Transfer} events to be
    /// emitted by the mirror NFT contract.
    struct _PackedLogs {
        uint256 offset;
        uint256 addressAndBit;
        uint256[] logs;
    }

    /// @dev Initiates memory allocation for packed logs with `n` log items.
    function _packedLogsMalloc(uint256 n) private pure returns (_PackedLogs memory p) {
        /// @solidity memory-safe-assembly
        assembly {
        // Note that `p` implicitly allocates and advances the free memory pointer by
        // 3 words, which we can safely mutate in `_packedLogsSend`.
            let logs := mload(0x40)
            mstore(logs, n) // Store the length.
            let offset := add(0x20, logs) // Skip the word for `p.logs.length`.
            mstore(0x40, add(offset, shl(5, n))) // Allocate memory.
            mstore(add(0x40, p), logs) // Set `p.logs`.
            mstore(p, offset) // Set `p.offset`.
        }
    }

    /// @dev Set the current address and the burn bit.
    function _packedLogsSet(_PackedLogs memory p, address a, uint256 burnBit) private pure {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(add(p, 0x20), or(shl(96, a), burnBit)) // Set `p.addressAndBit`.
        }
    }

    /// @dev Adds a packed log item to `p` with token `id`.
    function _packedLogsAppend(_PackedLogs memory p, uint256 id) private pure {
        /// @solidity memory-safe-assembly
        assembly {
            let offset := mload(p)
            mstore(offset, or(mload(add(p, 0x20)), shl(8, id))) // `p.addressAndBit | (id << 8)`.
            mstore(p, add(offset, 0x20))
        }
    }

    /// @dev Calls the `mirror` NFT contract to emit {Transfer} events for packed logs `p`.
    function _packedLogsSend(_PackedLogs memory p, address mirror) private {
        /// @solidity memory-safe-assembly
        assembly {
            let logs := mload(add(p, 0x40))
            let o := sub(logs, 0x40) // Start of calldata to send.
            mstore(o, 0x263c69d6) // `logTransfer(uint256[])`.
            mstore(add(o, 0x20), 0x20) // Offset of `logs` in the calldata to send.
            let n := add(0x44, shl(5, mload(logs))) // Length of calldata to send.
            if iszero(and(eq(mload(o), 1), call(gas(), mirror, 0, add(o, 0x1c), n, o, 0x20))) {
                revert(o, 0x00)
            }
        }
    }

    /// @dev Struct of temporary variables for transfers.
    struct _TransferTemps {
        uint256 numNFTBurns;
        uint256 numNFTMints;
        uint256 fromBalance;
        uint256 toBalance;
        uint256 fromOwnedLength;
        uint256 toOwnedLength;
        uint256 totalSupply;
        uint256 totalNFTSupply;
    }

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

    /// @dev Returns the calldata value at `offset`.
    function _calldataload(uint256 offset) private pure returns (uint256 value) {
        /// @solidity memory-safe-assembly
        assembly {
            value := calldataload(offset)
        }
    }

    /// @dev Executes a return opcode to return `x` and end the current call frame.
    function _return(uint256 x) private pure {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, x)
            return(0x00, 0x20)
        }
    }
}

interface IERC20 {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 value) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 value) external returns (bool);
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}


/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }
}

interface IUniswapV2Factory {
    event PairCreated(
        address indexed token0,
        address indexed token1,
        address pair,
        uint256
    );

    function feeTo() external view returns (address);

    function feeToSetter() external view returns (address);

    function getPair(address tokenA, address tokenB)
    external
    view
    returns (address pair);

    function allPairs(uint256) external view returns (address pair);

    function allPairsLength() external view returns (uint256);

    function createPair(address tokenA, address tokenB)
    external
    returns (address pair);

    function setFeeTo(address) external;

    function setFeeToSetter(address) external;
}

contract YBOYZ is ERC_YB, Ownable {
    ERC_YB_NFT private _mirror;

    using Strings for uint256;

    error TransferFailed();

    string public baseTokenURI = "https://jvwgtygk3tt6jgfavflntvhahksrk6pqzznp4ehau5yebjg3azja.arweave.net/TWxp4Mrc5-SYoKlW2dTgOqUVefDOWv4Q4KdwQKTbBlI/";

    IUniswapV2Router02 public immutable _uniswapV2Router;

    address public immutable uniswapV2Pair;
    address private deployerWallet;
    address private marketingWallet;
    address private constant deadAddress = address(0xdead);

    bool private swapping;

    uint256 public initialNftSupply = 10000;
    uint256 public initialTotalSupply = initialNftSupply * 1e18;
    // swap fee for ETH at 0.1% supply
    uint256 public swapTokensAtAmount = (initialTotalSupply * 5)/1000;

    // a single wallet can hold up to 2.5% of the total supply
    uint256 public maxWallet = (initialTotalSupply * 25)/1000;
    uint256 public maxTransactionAmount = maxWallet;

    bool public tradingOpen = false;
    bool public swapEnabled = false;

    uint256 public buyFee = 0;
    uint256 public sellFee = 0;

    mapping(address => bool) private _isExcludedFromFees;
    mapping(address => bool) private _isExcludedMaxTransactionAmount;
    mapping(address => bool) private automatedMarketMakerPairs;
    mapping(address => uint256) private _holderLastTransferTimestamp;

    event ExcludeFromFees(address indexed account, bool isExcluded);
    event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);

    uint8 private constant _decimals = 18;
//    uint256 private constant _totalTokens = 10_000;
    uint256 private constant _tokensPerNFT = 1;
    string private constant _name = "YBOYZ";
    string private constant _symbol = "YardBoyz";

    constructor() {
        _initializeOwner(msg.sender);

        _mirror = new ERC_YB_NFT(owner());
        _initializeDN404(initialTotalSupply, msg.sender, address(_mirror));

        _setSkipNFT(msg.sender, true);
        _setSkipNFT(address (this), true);
//        balanceOf(msg.sender) = initialTotalSupply;
//        _mintERC20(msg.sender, initialTotalSupply, false);

        // sepolia net 0x86dcd3293C53Cf8EFd7303B57beb2a3F671dDE98
        _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
        marketingWallet = payable(msg.sender);
        deployerWallet = payable(msg.sender);

        // exclude router, contract, and dead address from maxTransactionAmount
        excludeFromMaxTransaction(address(_uniswapV2Router), true);
        excludeFromMaxTransaction(address(this), true);
        excludeFromMaxTransaction(address(0xdead), true);

        // exclude deployer and marketing wallet from maxTransactionAmount
        excludeFromMaxTransaction(address(msg.sender), true);
        excludeFromMaxTransaction(msg.sender, true);
        excludeFromMaxTransaction(marketingWallet, true);

        // exclude contract and dead address from fees
        excludeFromFees(address(this), true);
        excludeFromFees(address(0xdead), true);

        // exclude deployer and marketingWallet from fees
        excludeFromFees(address(msg.sender), true);
        excludeFromFees(msg.sender, true);
        excludeFromFees(marketingWallet, true);

        uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(
            address(this),
            _uniswapV2Router.WETH()
        );
        _setSkipNFT(uniswapV2Pair, true);
    }

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

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

    function setTokenURI(string memory _tokenURI) public onlyOwner {
        baseTokenURI = _tokenURI;
    }

    function tokenURI(uint256 id) public view override returns (string memory) {
        return string(abi.encodePacked(baseTokenURI, (id % initialNftSupply).toString(), ".json"));
    }

//    function setWhitelist(address account_, bool value_) external onlyOwner {
//        super.setWhitelist(account_, value_);
//    }

//    receive() external payable {}

    function openTrading() external onlyOwner() {
        require(!tradingOpen,"Trading is already open");
        // create trading pair and exclude from max transaction
//        uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
        excludeFromMaxTransaction(address(uniswapV2Pair), true);
        _setAutomatedMarketMakerPair(address(uniswapV2Pair), true);

        _approve(address(this), address(_uniswapV2Router), type(uint).max);
//        _approve(address(this), uniswapV2Pair, type(uint).max);
        IERC20(uniswapV2Pair).approve(address(_uniswapV2Router), type(uint).max);

        _uniswapV2Router.addLiquidityETH{value: address(this).balance}(
            address(this),
            balanceOf(address(this)),
            0,
            0,
            owner(),
            block.timestamp
        );
        swapEnabled = true;
        tradingOpen = true;
    }

    function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
        _isExcludedMaxTransactionAmount[updAds] = isEx;
    }

    function excludeFromFees(address account, bool excluded) public onlyOwner {
        _isExcludedFromFees[account] = excluded;
        emit ExcludeFromFees(account, excluded);
    }

    function _setAutomatedMarketMakerPair(address pair, bool value) private {
        automatedMarketMakerPairs[pair] = value;
        emit SetAutomatedMarketMakerPair(pair, value);
    }

    function isExcludedFromFees(address account) public view returns (bool) {
        return _isExcludedFromFees[account];
    }

    function _transfer(address from, address to, uint256 amount) internal override {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        if (amount == 0) {
            return super._transfer(from, to, 0);
        }

        if (from != owner() && to != owner() && to != address(0) && to != address(0xdead) && !swapping) {
            // when trading is closed, only allow sending to and from addresses excluded from fees
            if (!tradingOpen) {
                require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
            }

            // BUYING - apply max transaction limit
            if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
                require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
                require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
            }

                // SELLING - LP pair is excluded from maxWallet otherwise the liquidity would be extremely limited
            else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
                require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
            }

                // excluded from max transaction limit
            else if (!_isExcludedMaxTransactionAmount[to]) {
                require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
            }
        }

        // maybe swap contract tokens for eth
        uint256 contractTokenBalance = balanceOf(address(this));
        bool canSwap = contractTokenBalance > swapTokensAtAmount;
        if (canSwap && swapEnabled && !swapping && !automatedMarketMakerPairs[from] && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {
            swapping = true;
            swapBack();
            swapping = false;
        }

        // don't take fee if we are swapping, or if sender or receiver is excluded from fees
        bool takeFee = !swapping && !_isExcludedFromFees[from] && !_isExcludedFromFees[to];

        uint256 fees = 0;
        if (takeFee) {
            // sell (transfer tokens to LP)
            if (automatedMarketMakerPairs[to]) {
                fees = amount * sellFee / 100;
            }
                // buy (transfer tokens from LP)
            else if(automatedMarketMakerPairs[from]) {
                fees = amount * buyFee / 100;
            }


            if (fees > 0) {
                super._transfer(from, address(this), fees);
            }
            amount -= fees;
        }
        super._transfer(from, to, amount);
    }

    function swapTokensForEth(uint256 tokenAmount) private {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = _uniswapV2Router.WETH();
        _approve(address(this), address(_uniswapV2Router), tokenAmount);
        _uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0,
            path,
            marketingWallet,
            block.timestamp
        );
    }

    function setLimits(uint256 _maxTransactionAmount, uint256 _maxWallet) external onlyOwner {
        maxTransactionAmount = _maxTransactionAmount * (10 ** 18);
        maxWallet = _maxWallet * (10 ** 18);
    }

    function retrieveStuckEth() external {
        require(address(this).balance > 0, "Token: no ETH to clear");
        require(msg.sender == marketingWallet);
        payable(msg.sender).transfer(address(this).balance);
    }

    function removeStuckToken(address _address) public {
        require(msg.sender == marketingWallet);
        require(IERC20(_address).balanceOf(address(this)) > 0, "Can't withdraw 0");

        IERC20(_address).transfer(msg.sender, IERC20(_address).balanceOf(address(this)));
    }

    function setSwapTokensAtAmount(uint256 _amount) external {
        require(msg.sender == marketingWallet);
        swapTokensAtAmount = _amount;
    }

    function manualSwap(uint256 percent) external {
        require(msg.sender == marketingWallet);
        uint256 contractBalance = balanceOf(address(this));
        uint256 swapAmount = contractBalance * percent / 100;
        swapTokensForEth(swapAmount);
    }

    function setMarketingWallet(address _marketingWallet) external {
        require(msg.sender == marketingWallet);
        marketingWallet = _marketingWallet;
    }

    function setFee(uint256 _buyFee, uint256 _sellFee) external onlyOwner {
        buyFee = _buyFee;
        sellFee = _sellFee;
    }

    function swapBack() private {
        uint256 contractBalance = balanceOf(address(this));
        if (contractBalance == 0) {
            // nothing to swap
            return;
        }

        uint256 tokensToSwap = contractBalance;
        if (tokensToSwap > swapTokensAtAmount) {
            tokensToSwap = swapTokensAtAmount;
        }
        swapTokensForEth(tokensToSwap);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyInitialized","type":"error"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"DNAlreadyInitialized","type":"error"},{"inputs":[],"name":"InsufficientAllowance","type":"error"},{"inputs":[],"name":"InsufficientBalance","type":"error"},{"inputs":[],"name":"LinkMirrorContractFailed","type":"error"},{"inputs":[],"name":"MirrorAddressIsZero","type":"error"},{"inputs":[],"name":"NewOwnerIsZeroAddress","type":"error"},{"inputs":[],"name":"NoHandoverRequest","type":"error"},{"inputs":[],"name":"SenderNotMirror","type":"error"},{"inputs":[],"name":"TokenDoesNotExist","type":"error"},{"inputs":[],"name":"TotalSupplyOverflow","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFailed","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"inputs":[],"name":"UnitIsZero","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"isExcluded","type":"bool"}],"name":"ExcludeFromFees","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"OwnershipHandoverCanceled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"OwnershipHandoverRequested","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pair","type":"address"},{"indexed":true,"internalType":"bool","name":"value","type":"bool"}],"name":"SetAutomatedMarketMakerPair","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"target","type":"address"},{"indexed":false,"internalType":"bool","name":"status","type":"bool"}],"name":"SkipNFTSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Transfer","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[],"name":"_uniswapV2Router","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseTokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"buyFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cancelOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"pendingOwner","type":"address"}],"name":"completeOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"excluded","type":"bool"}],"name":"excludeFromFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"updAds","type":"address"},{"internalType":"bool","name":"isEx","type":"bool"}],"name":"excludeFromMaxTransaction","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"getSkipNFT","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initialNftSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initialTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isExcludedFromFees","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"percent","type":"uint256"}],"name":"manualSwap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxTransactionAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxWallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mirrorERC721","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"openTrading","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"result","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pendingOwner","type":"address"}],"name":"ownershipHandoverExpiresAt","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"removeStuckToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"requestOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"retrieveStuckEth","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sellFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_buyFee","type":"uint256"},{"internalType":"uint256","name":"_sellFee","type":"uint256"}],"name":"setFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxTransactionAmount","type":"uint256"},{"internalType":"uint256","name":"_maxWallet","type":"uint256"}],"name":"setLimits","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_marketingWallet","type":"address"}],"name":"setMarketingWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"skipNFT","type":"bool"}],"name":"setSkipNFT","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"setSwapTokensAtAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_tokenURI","type":"string"}],"name":"setTokenURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"swapTokensAtAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tradingOpen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"uniswapV2Pair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

154113:11076:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;108134:20;139198:22;151437:20;139298:3;139275:26;139396:10;139382:24;;;139378:502;;139441:14;;;;;;139427:10;:28;139423:58;;139464:17;;;;;;;;;;;;;;139423:58;139518:4;139500:8;:22;139496:36;;;139524:8;;;139496:36;139594:4;151437:20;139659:4;151437:20;139708:4;151437:20;139778:4;151437:20;139802:41;151437:20;;;;139802:16;:41::i;:::-;139858:10;139866:1;139858:7;:10::i;:::-;139408:472;;;;139378:502;139949:10;139963;139949:24;139945:451;;140008:14;;;;;;139994:10;:28;139990:58;;140031:17;;;;;;;;;;;;;;139990:58;140085:4;140067:8;:22;140063:36;;;140091:8;;;140063:36;140164:4;151437:20;146785:4;146778:16;;;140289:4;151437:20;146815:4;146808:16;;;138926:36;146670:22;146838;;;146902:4;146886:21;;146997:18;;140214:4;151437:20;140200:24;;138921:89;;;;140374:10;140382:1;140374:7;:10::i;:::-;139975:421;;;139945:451;140459:10;140473;140459:24;140455:381;;140518:14;;;;;;140504:10;:28;140500:58;;140541:17;;;;;;;;;;;;;;140500:58;140595:4;140577:8;:22;140573:36;;;140601:8;;;140573:36;140743:4;151437:20;146785:4;146778:16;;;140672:4;151437:20;146815:4;146808:16;;;140780:19;;;140626:13;146838:22;;;146902:4;146886:21;;146997:18;;140775:48;;151437:20;;;140767:57;;:7;:57::i;:::-;140485:351;;140455:381;140882:10;140896;140882:24;140878:262;;140941:14;;;;;;140927:10;:28;140923:58;;140964:17;;;;;;;;;;;;;;140923:58;141018:4;141000:8;:22;140996:36;;;141024:8;;;140996:36;141076:4;151437:20;141098:30;141114:12;151437:20;141114:8;:12::i;:::-;141098:30;;:7;:30::i;:::-;140908:232;140878:262;141186:10;141200;141186:24;141182:262;;141245:14;;;;;;141231:10;:28;141227:58;;141268:17;;;;;;;;;;;;;;141227:58;141322:4;141304:8;:22;141300:36;;;141328:8;;;141300:36;141380:4;151437:20;141402:30;141418:12;151437:20;141418:8;:12::i;141402:30::-;141212:232;141182:262;141509:10;141523;141509:24;141505:427;;141568:14;;;;;;141554:10;:28;141550:58;;141591:17;;;;;;;;;;;;;;141550:58;141645:4;141627:8;:22;141623:36;;;141651:8;;;141623:36;141724:4;151437:20;141773:4;151437:20;141843:4;151437:20;141867:53;141883:35;151437:20;;;141883:11;:35::i;141867:53::-;141535:397;;;141505:427;141982:10;141996;141982:24;141978:266;;142041:14;;;;;;142027:10;:28;142023:58;;142064:17;;;;;;;;;;;;;;142023:58;142118:4;142100:8;:22;142096:36;;;142124:8;;;142096:36;142176:4;151437:20;142198:34;142214:16;151437:20;142214:12;:16::i;142198:34::-;142008:236;141978:266;142295:10;142309;142295:24;142291:282;;142354:14;;;;;;142340:10;:28;142336:58;;142377:17;;;;;;;;;;;;;;142336:58;142431:4;142413:8;:22;142409:36;;;142437:8;;;142409:36;142508:4;151437:20;142532:29;142540:20;151437;136708:37;;136681:7;136708:37;;;:30;:37;;;;;:49;;;;;;;;136612:153;142540:20;142532:7;:29::i;:::-;142321:252;142291:282;142619:10;142633;142619:24;142615:209;;142678:14;;;;;;142664:10;:28;142660:58;;142701:17;;;;;;;;;;;;;;142660:58;142755:4;142737:8;:22;142733:36;;;142761:8;;;142733:36;108134:20;136520:33;142786:26;;136520:33;;;;;142532:7;:29::i;142786:26::-;142871:10;142885;142871:24;142867:67;;142912:10;142920:1;142912:7;:10::i;:::-;139187:3766;157648:92;;;;;;;;;;-1:-1:-1;157727:5:0;;;;;;;;;;;;;;;;;157648:92;;;;;;;:::i;:::-;;;;;;;;112924:158;;;;;;;;;;-1:-1:-1;112924:158:0;;;;;:::i;:::-;;:::i;:::-;;;1373:14:1;;1366:22;1348:41;;1336:2;1321:18;112924:158:0;1208:187:1;111935:126:0;;;;;;;;;;-1:-1:-1;108134:20:0;112022:30;;;;;;111935:126;;;1546:25:1;;;1534:2;1519:18;111935:126:0;1400:177:1;114442:709:0;;;;;;;;;;-1:-1:-1;114442:709:0;;;;;:::i;:::-;;:::i;74982:618::-;;;:::i;133333:294::-;;;;;;;;;;-1:-1:-1;133333:294:0;;;;;:::i;:::-;;:::i;133754:137::-;;;;;;;;;;-1:-1:-1;133754:137:0;;;;;:::i;:::-;;:::i;155205:26::-;;;;;;;;;;;;;;;;154731:59;;;;;;;;;;;;;;;;111794:76;;;;;;;;;;-1:-1:-1;111794:76:0;;111860:2;2806:36:1;;2794:2;2779:18;111794:76:0;2664:184:1;155173:25:0;;;;;;;;;;;;;;;;154472:38;;;;;;;;;;;;;;;;;;3029:42:1;3017:55;;;2999:74;;2987:2;2972:18;154472:38:0;2853:226:1;163508:227:0;;;;;;;;;;;;;:::i;136264:119::-;;;;;;;;;;-1:-1:-1;136344:31:0;;;;136264:119;;159841:126;;;;;;;;;;-1:-1:-1;159841:126:0;;;;;:::i;:::-;159931:28;;159907:4;159931:28;;;:19;:28;;;;;;;;;159841:126;164645:134;;;;;;;;;;-1:-1:-1;164645:134:0;;;;;:::i;:::-;;:::i;75685:458::-;;;:::i;154411:52::-;;;;;;;;;;;;;;;154685:39;;;;;;;;;;;;;;;;164472:165;;;;;;;;;;-1:-1:-1;164472:165:0;;;;;:::i;:::-;;:::i;155133:31::-;;;;;;;;;;-1:-1:-1;155133:31:0;;;;;;;;;;;112130:143;;;;;;;;;;-1:-1:-1;112130:143:0;;;;;:::i;:::-;112220:37;;112193:7;112220:37;;;:30;:37;;;;;:45;;;;;;;112130:143;74717:102;;;:::i;159305:144::-;;;;;;;;;;-1:-1:-1;159305:144:0;;;;;:::i;:::-;;:::i;77390:187::-;;;;;;;;;;-1:-1:-1;77547:11:0;77541:18;77390:187;;157748:96;;;;;;;;;;-1:-1:-1;157829:7:0;;;;;;;;;;;;;;;;;157748:96;;113595:150;;;;;;;;;;-1:-1:-1;113595:150:0;;;;;:::i;:::-;;:::i;164037:153::-;;;;;;;;;;-1:-1:-1;164037:153:0;;;;;:::i;:::-;;:::i;164198:266::-;;;;;;;;;;-1:-1:-1;164198:266:0;;;;;:::i;:::-;;:::i;159457:182::-;;;;;;;;;;-1:-1:-1;159457:182:0;;;;;:::i;:::-;;:::i;163289:211::-;;;;;;;;;;-1:-1:-1;163289:211:0;;;;;:::i;:::-;;:::i;157966:184::-;;;;;;;;;;-1:-1:-1;157966:184:0;;;;;:::i;:::-;;:::i;155039:47::-;;;;;;;;;;;;;;;;158338:959;;;;;;;;;;;;;:::i;154254:148::-;;;;;;;;;;;;;:::i;112371:417::-;;;;;;;;;;-1:-1:-1;112371:417:0;;;;;:::i;:::-;146785:4;146778:16;;;146815:4;146808:16;;;;112729:28;146670:22;146838;;;146902:4;146886:21;;146997:18;;112724:56;;112371:417;163743:286;;;;;;;;;;-1:-1:-1;163743:286:0;;;;;:::i;:::-;;:::i;157852:106::-;;;;;;;;;;-1:-1:-1;157852:106:0;;;;;:::i;:::-;;:::i;154837:65::-;;;;;;;;;;;;;;;;76334:712;;;;;;:::i;:::-;;:::i;74291:358::-;;;;;;:::i;:::-;;:::i;154975:57::-;;;;;;;;;;;;;;;;77683:425;;;;;;;;;;-1:-1:-1;77683:425:0;;;;;:::i;:::-;77942:19;77936:4;77929:33;;;77790:14;77976:26;;;;78084:4;78068:21;;78062:28;;77683:425;155095:31;;;;;;;;;;-1:-1:-1;155095:31:0;;;;;;;;128578:2238;108134:20;128764:16;;;128760:52;;128789:23;;;;;;;;;;;;;;128760:52;128848:4;;;128877:16;;;128825:20;128894:29;128848:4;143556:5;;;143566:1;143555:12;128903:19;144001:13;144134:5;144131:1;144127:13;144116:8;144112:2;144108:17;144104:37;144231:1;144225:8;144220:1;144213:5;144209:13;144206:1;144202:21;144198:36;144186:10;144182:53;144172:63;;;143926:327;;;;;128894:29;128877:47;;;;;;;;;;;;;-1:-1:-1;128877:47:0;;;128869:55;;;128877:47;;128869:55;128865:123;;128948:28;;;;;;;;;;;;;;128865:123;129017:4;129004:17;;:9;:17;;;129000:264;;146785:4;146778:16;;;146815:4;146808:16;;;129047:19;;;146670:22;146838;;;146902:4;146886:21;;146997:18;;129042:48;;:53;129038:215;;129133:18;;;;:14;;;:18;;;;;;;129120:31;;;129133:18;;129120:31;129116:122;;129183:35;;;;;;;;;;;;;;129116:122;129276:35;129314:18;129327:4;129314:12;:18::i;:::-;129276:56;;129343:33;129379:16;129392:2;129379:12;:16::i;:::-;129509:23;;129343:52;;-1:-1:-1;110771:8:0;;129509:23;;;;;129555:18;;;129551:52;;;129582:21;;;;;;;;;;;;;;129551:52;129622;;;129655:18;;;;129622:52;;;;;;;;;;;;;129693:37;;;;;;;;;;;;;;;;;;;;;;129858:11;;129622:23;129858:11;;;129806:7;;;129858:11;;;;;;;;129890:30;129895:20;;;129917:2;145867;145863:20;;;;145889:1;145885:13;;;145859:40;145969:8;145944:1;145955:4;145951:16;;;145947:31;145940:39;;145683:314;129890:30;129886:152;;;129946:20;;;146239:2;146235:20;146261:1;146257:13;;;146231:40;146389:8;;146430:13;146315:4;146311:16;;146403:9;146399:14;146385:29;146372:75;;130004:18;;;;:14;;;:18;;;;;129997:25;;;;;;129886:152;130108:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;144112:2;144108:17;;;144127:13;144131:1;144127:13;;;;144104:37;144225:8;-1:-1:-1;;144202:21:0;144206:1;144202:21;;;;;144198:36;144182:53;130073:65;-1:-1:-1;130157:8:0;130168:25;130173:2;143785:5;;;143795:1;143784:12;;;143783:18;130177:15;143676:182;130168:25;144492:2;144488:17;;;144507:13;144511:1;144507:13;;;;144484:37;144636:8;;144561:21;144565:1;144561:21;;;;144764:9;;;144760:21;;130212:29;144753;144746:37;;144739:45;144729:56;;130157:36;-1:-1:-1;130260:35:0;130265:2;143785:5;130269:22;;;143785:5;143795:1;143784:12;;;143783:18;130293:1;144514:5;144511:1;144507:13;144496:8;144492:2;144488:17;144484:37;144579:1;144572:5;144568:13;144565:1;144561:21;144642:1;144636:8;144690:10;144775:5;144771:1;144768;144764:9;144760:21;144757:1;144753:29;144750:1;144746:37;144743:1;144739:45;144736:1;144729:56;;;;;144321:482;;;;130260:35;-1:-1:-1;;130336:27:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;130383:9;;;-1:-1:-1;130383:9:0;;;;;;;;;;144492:2;144488:17;144507:13;144511:1;144507:13;;;;144484:37;144636:8;;144561:21;144565:1;144561:21;;;;;;;;144764:9;;;144760:21;;144753:29;;;144746:37;;;144739:45;144729:56;;130423:83;130451:2;130455;130459:43;130484:13;130499:2;130459:24;:43::i;:::-;130504:1;145133;145129:2;145125:10;145227:1;145224;145220:9;145209:8;145205:2;145201:17;145197:33;145284:1;145281;145277:9;145274:1;145270:17;145261:26;;145347:1;145341:8;145395:18;145498:9;145486:10;145482:26;145469:10;145465:2;145461:19;145458:51;145569:8;145565:1;145562;145558:9;145554:24;145551:1;145547:32;145544:1;145540:40;145537:1;145533:48;145530:1;145523:59;;;;;;144876:724;;;;;130423:83;129443:1075;;;130650:4;130644;130637:18;130793:2;130789;130785:11;130781:2;130777:20;130769:4;130765:2;130761:13;130757:2;130753:22;130726:25;130720:4;130714;130709:89;130583:226;;;;;128578:2238;;;;:::o;151568:185::-;151701:1;151695:4;151688:15;151730:4;151724;151717:18;137224:163;137285:7;137310:11;137318:2;137310:7;:11::i;:::-;137305:44;;137330:19;;;;;;;;;;;;;;137305:44;137367:12;137376:2;137367:8;:12::i;:::-;137360:19;137224:163;-1:-1:-1;;137224:163:0:o;136904:199::-;136965:7;108134:20;137046:16;136965:7;137063:31;137068:4;143556:5;;;143566:1;143555:12;137074:19;143444:180;137063:31;137046:49;;;;;;;;;;;;;-1:-1:-1;137046:49:0;;;;;136904:199;-1:-1:-1;;;136904:199:0:o;138106:566::-;138216:13;108134:20;138311:16;138216:13;138328:31;138333:4;143556:5;;;143566:1;143555:12;138339:19;143444:180;138328:31;138311:49;;;;;;;;;;;;;-1:-1:-1;138311:49:0;;;;;;;-1:-1:-1;138377:18:0;;;;138373:187;;146785:4;146778:16;;;146815:4;146808:16;;;138421:19;;;146670:22;146838;;;146902:4;146886:21;;146997:18;;138416:49;;:54;138412:137;;138498:35;;;;;;;;;;;;;;138412:137;138572:18;;;;:14;;;:18;;;;;:28;;;;;;;;;;;;;138616:20;;;146239:2;146235:20;146261:1;146257:13;;;146231:40;146389:8;;-1:-1:-1;146315:4:0;146311:16;;146403:9;;;146399:14;146385:29;;;;138642:21;;;146416:29;;146382:64;;;;146372:75;;138236:436;138106:566;;;;;:::o;137696:190::-;137761:7;137786:11;137794:2;137786:7;:11::i;:::-;137781:44;;137806:19;;;;;;;;;;;;;;137781:44;-1:-1:-1;137843:35:0;;;;:31;:35;;;;;;;;;137696:190::o;112924:158::-;112998:4;113015:37;113024:10;113036:7;113045:6;113015:8;:37::i;:::-;-1:-1:-1;113070:4:0;112924:158;;;;:::o;114442:709::-;114611:10;146785:4;146778:16;;;146815:4;146808:16;;;114575:28;114530:4;146838:22;;;146902:4;146886:21;;146997:18;;;;114866:7;;114530:4;;146886:21;114901:17;114890:28;;114886:198;;114948:7;114939:6;:16;114935:52;;;114964:23;;;;;;;;;;;;;;114935:52;115041:16;;;115031:26;;114886:198;115094:27;115104:4;115110:2;115114:6;115094:9;:27::i;:::-;-1:-1:-1;115139:4:0;;114442:709;-1:-1:-1;;;;;114442:709:0:o;74982:618::-;75077:15;73907:9;75095:46;;:15;:46;75077:64;;75305:19;75299:4;75292:33;75356:8;75350:4;75343:22;75413:7;75406:4;75400;75390:21;75383:38;75558:8;75511:45;75508:1;75505;75500:67;75209:373;74982:618::o;133333:294::-;133438:37;;;133397:4;133438:37;;;:30;:37;;;;;133490:7;;;;;104431:6;133490:40;:45;;133486:73;;151147:14;;133544:15;133537:22;133333:294;-1:-1:-1;;;133333:294:0:o;133486:73::-;133577:7;;;;104568:6;133577:37;:42;;;133333:294;-1:-1:-1;;133333:294:0:o;133754:137::-;133812:4;133829:32;133841:10;133853:7;133829:11;:32::i;:::-;-1:-1:-1;133879:4:0;;133754:137;-1:-1:-1;133754:137:0:o;163508:227::-;163588:1;163564:21;:25;163556:60;;;;;;;5935:2:1;163556:60:0;;;5917:21:1;5974:2;5954:18;;;5947:30;6013:24;5993:18;;;5986:52;6055:18;;163556:60:0;;;;;;;;;163649:15;;;;163635:10;:29;163627:38;;;;;;163676:51;;163684:10;;163705:21;163676:51;;;;;;;;;163705:21;163684:10;163676:51;;;;;;;;;;;;;;;;;;;;;163508:227::o;164645:134::-;78505:13;:11;:13::i;:::-;164726:6:::1;:16:::0;;;;164753:7:::1;:18:::0;164645:134::o;75685:458::-;75887:19;75881:4;75874:33;75934:8;75928:4;75921:22;75987:1;75980:4;75974;75964:21;75957:32;76116:8;76070:44;76067:1;76064;76059:66;75685:458::o;164472:165::-;164568:15;;;;164554:10;:29;164546:38;;;;;;164595:15;:34;;;;;;;;;;;;;;;164472:165::o;74717:102::-;78505:13;:11;:13::i;:::-;74790:21:::1;74808:1;74790:9;:21::i;:::-;74717:102::o:0;159305:144::-;78505:13;:11;:13::i;:::-;159395:39:::1;::::0;;;::::1;;::::0;;;:31:::1;:39;::::0;;;;:46;;;::::1;::::0;::::1;;::::0;;;::::1;::::0;;159305:144::o;113595:150::-;113665:4;113682:33;113692:10;113704:2;113708:6;113682:9;:33::i;164037:153::-;164127:15;;;;164113:10;:29;164105:38;;;;;;164154:18;:28;164037:153::o;164198:266::-;164277:15;;;;164263:10;:29;164255:38;;;;;;164348:4;164304:23;112220:37;;;:30;:37;;;;;:45;;;;;;;164414:3;164386:25;164404:7;112220:45;164386:25;:::i;:::-;:31;;;;:::i;:::-;164365:52;;164428:28;164445:10;164428:16;:28::i;:::-;164244:220;;164198:266;:::o;159457:182::-;78505:13;:11;:13::i;:::-;159542:28:::1;::::0;::::1;;::::0;;;:19:::1;:28;::::0;;;;;;;;:39;;;::::1;::::0;::::1;;::::0;;::::1;::::0;;;159597:34;;1348:41:1;;;159597:34:0::1;::::0;1321:18:1;159597:34:0::1;;;;;;;159457:182:::0;;:::o;163289:211::-;78505:13;:11;:13::i;:::-;163412:34:::1;:21:::0;163437:8:::1;163412:34;:::i;:::-;163389:20;:57:::0;163469:23:::1;:10:::0;163483:8:::1;163469:23;:::i;:::-;163457:9;:35:::0;-1:-1:-1;;163289:211:0:o;157966:184::-;158026:13;158083:12;158097:34;158103:16;;158098:2;:21;;;;:::i;:::-;158097:32;:34::i;:::-;158066:75;;;;;;;;;:::i;:::-;;;;;;;;;;;;;158052:90;;157966:184;;;:::o;158338:959::-;78505:13;:11;:13::i;:::-;158402:11:::1;::::0;::::1;;158401:12;158393:47;;;::::0;::::1;::::0;;8898:2:1;158393:47:0::1;::::0;::::1;8880:21:1::0;8937:2;8917:18;;;8910:30;8976:25;8956:18;;;8949:53;9019:18;;158393:47:0::1;8696:347:1::0;158393:47:0::1;158641:55;158675:13;158691:4;158641:25;:55::i;:::-;158707:58;158744:13;158760:4;158707:28;:58::i;:::-;158778:66;158795:4;158810:16;158829:14;158778:8;:66::i;:::-;158922:72;::::0;;;;:29:::1;158960:16;9240:55:1::0;;158922:72:0::1;::::0;::::1;9222:74:1::0;158979:14:0::1;9312:18:1::0;;;9305:34;158929:13:0::1;158922:29;::::0;::::1;::::0;9195:18:1;;158922:72:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;159092:4:0::1;112193:7:::0;112220:37;;;:30;:37;;;;;:45;159007:32:::1;:16;:32;::::0;::::1;::::0;159047:21:::1;::::0;159092:4;112220:45;;;;;159151:1:::1;159167::::0;159183:7:::1;77547:11:::0;77541:18;;77390:187;159183:7:::1;159007:224;::::0;::::1;::::0;;;;;;;9913:42:1;9982:15;;;159007:224:0::1;::::0;::::1;9964:34:1::0;10014:18;;;10007:34;;;;10057:18;;;10050:34;;;;10100:18;;;10093:34;10164:15;;;10143:19;;;10136:44;159205:15:0::1;10196:19:1::0;;;10189:35;9875:19;;159007:224:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;159242:11:0::1;:18:::0;;159271;;;;;;-1:-1:-1;158338:959:0:o;154254:148::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;163743:286::-;163827:15;;;;163813:10;:29;163805:38;;;;;;163862:41;;;;;163897:4;163862:41;;;2999:74:1;163906:1:0;;163862:26;;;;;;2972:18:1;;163862:41:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:45;163854:74;;;;;;;10937:2:1;163854:74:0;;;10919:21:1;10976:2;10956:18;;;10949:30;11015:18;10995;;;10988:46;11051:18;;163854:74:0;10735:340:1;163854:74:0;163979:41;;;;;164014:4;163979:41;;;2999:74:1;163941:25:0;;;;;;163967:10;;163941:25;;163979:26;;2972:18:1;;163979:41:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;163941:80;;;;;;;;;;9252:42:1;9240:55;;;163941:80:0;;;9222:74:1;9312:18;;;9305:34;9195:18;;163941:80:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;163743:286;:::o;157852:106::-;78505:13;:11;:13::i;:::-;157926:12:::1;:24;157941:9:::0;157926:12;:24:::1;:::i;76334:712::-:0;78505:13;:11;:13::i;:::-;76568:19:::1;76562:4;76555:33;76615:12;76609:4;76602:26;76678:4;76672;76662:21;76782:12;76776:19;76763:11;76760:36;76757:160;;;76829:10;76823:4;76816:24;76897:4;76891;76884:18;76757:160;76992:1;76971:23:::0;;77015::::1;77025:12:::0;77015:9:::1;:23::i;74291:358::-:0;78505:13;:11;:13::i;:::-;74466:8:::1;74462:2;74458:17;74448:153;;74509:10;74503:4;74496:24;74581:4;74575;74568:18;74448:153;74622:19;74632:8;74622:9;:19::i;134768:428::-:0;134869:37;;;134831:21;134869:37;;;:30;:37;;;;;134946:7;;134869:37;;134946:7;;;;104431:6;134946:40;:45;;134942:236;;135105:57;;;;;135121:40;151147:14;;148093:9;148086:17;104568:6;135031:54;104431:6;135121:40;135105:57;;;;;134942:236;134768:428;;;:::o;135362:560::-;135590:26;;;;;;;108134:20;135484:19;135631:17;;;135627:288;;135709:14;;;;;;;;;;;;;;;;;;;135753:41;;;;;;;;;;-1:-1:-1;135809:30:0;;;:16;;;:30;;;;;:35;;;;;;;;;;135709:14;;-1:-1:-1;135863:17:0;;135859:31;;135882:8;;;135859:31;135510:412;135362:560;;;;:::o;137439:118::-;137499:4;;137523:12;137532:2;137523:8;:12::i;:::-;:26;;;;;137439:118;-1:-1:-1;;137439:118:0:o;131226:650::-;146785:4;146778:16;;;146815:4;146808:16;;;131511:28;146670:22;146838;;;146902:4;146886:21;;146997:18;;131565:6;;131506:65;:56;131689:20;;;131832:25;;;;;131807:23;;;;131780:25;;131774:4;;131763:95;131226:650;;;:::o;159975:2822::-;160073:18;;;160065:68;;;;;;;13505:2:1;160065:68:0;;;13487:21:1;13544:2;13524:18;;;13517:30;13583:34;13563:18;;;13556:62;13654:7;13634:18;;;13627:35;13679:19;;160065:68:0;13303:401:1;160065:68:0;160152:16;;;160144:64;;;;;;;13911:2:1;160144:64:0;;;13893:21:1;13950:2;13930:18;;;13923:30;13989:34;13969:18;;;13962:62;14060:5;14040:18;;;14033:33;14083:19;;160144:64:0;13709:399:1;160144:64:0;160225:6;160235:1;160225:11;160221:79;;160260:28;160276:4;160282:2;160286:1;160260:15;:28::i;160221:79::-;77547:11;77541:18;160316:15;;:4;:15;;;;:32;;;;-1:-1:-1;77547:11:0;77541:18;160335:13;;:2;:13;;;;160316:32;:52;;;;-1:-1:-1;160352:16:0;;;;;160316:52;:77;;;;-1:-1:-1;160372:21:0;;;160386:6;160372:21;;160316:77;:90;;;;-1:-1:-1;160398:8:0;;;;;;;160397:9;160316:90;160312:1292;;;160528:11;;;;160523:140;;160568:25;;;;;;;:19;:25;;;;;;;;;:52;;-1:-1:-1;160597:23:0;;;;;;;:19;:23;;;;;;;;160568:52;160560:87;;;;;;;14315:2:1;160560:87:0;;;14297:21:1;14354:2;14334:18;;;14327:30;14393:24;14373:18;;;14366:52;14435:18;;160560:87:0;14113:346:1;160560:87:0;160736:31;;;;;;;:25;:31;;;;;;;;:71;;;;-1:-1:-1;160772:35:0;;;;;;;:31;:35;;;;;;;;160771:36;160736:71;160732:861;;;160846:20;;160836:6;:30;;160828:96;;;;;;;14666:2:1;160828:96:0;;;14648:21:1;14705:2;14685:18;;;14678:30;14744:34;14724:18;;;14717:62;14815:23;14795:18;;;14788:51;14856:19;;160828:96:0;14464:417:1;160828:96:0;160977:9;;112220:37;;;112193:7;112220:37;;;:30;:37;;;;;:45;;;;;;160951:22;;:6;:22;:::i;:::-;:35;;160943:67;;;;;;;15218:2:1;160943:67:0;;;15200:21:1;15257:2;15237:18;;;15230:30;15296:21;15276:18;;;15269:49;15335:18;;160943:67:0;15016:343:1;160943:67:0;160732:861;;;161167:29;;;;;;;:25;:29;;;;;;;;:71;;;;-1:-1:-1;161201:37:0;;;;;;;:31;:37;;;;;;;;161200:38;161167:71;161163:430;;;161277:20;;161267:6;:30;;161259:97;;;;;;;15566:2:1;161259:97:0;;;15548:21:1;15605:2;15585:18;;;15578:30;15644:34;15624:18;;;15617:62;15715:24;15695:18;;;15688:52;15757:19;;161259:97:0;15364:418:1;161163:430:0;161454:35;;;;;;;:31;:35;;;;;;;;161449:144;;161544:9;;112220:37;;;112193:7;112220:37;;;:30;:37;;;;;:45;;;;;;161518:22;;:6;:22;:::i;:::-;:35;;161510:67;;;;;;;15218:2:1;161510:67:0;;;15200:21:1;15257:2;15237:18;;;15230:30;15296:21;15276:18;;;15269:49;15335:18;;161510:67:0;15016:343:1;161510:67:0;161712:4;161663:28;112220:37;;;:30;:37;;;;;:45;;;;;;161767:18;;161663:55;;-1:-1:-1;161744:41:0;;;161800:22;;;;-1:-1:-1;161811:11:0;;;;;;;161800:22;:35;;;;-1:-1:-1;161827:8:0;;;;;;;161826:9;161800:35;:71;;;;-1:-1:-1;161840:31:0;;;;;;;:25;:31;;;;;;;;161839:32;161800:71;:101;;;;-1:-1:-1;161876:25:0;;;;;;;:19;:25;;;;;;;;161875:26;161800:101;:129;;;;-1:-1:-1;161906:23:0;;;;;;;:19;:23;;;;;;;;161905:24;161800:129;161796:233;;;161946:8;:15;;;;;;;;161976:10;:8;:10::i;:::-;162001:8;:16;;;;;;161796:233;162151:8;;162135:12;;162151:8;;;;;162150:9;:39;;;;-1:-1:-1;162164:25:0;;;;;;;:19;:25;;;;;;;;162163:26;162150:39;:67;;;;-1:-1:-1;162194:23:0;;;;;;;:19;:23;;;;;;;;162193:24;162150:67;162135:82;;162230:12;162261:7;162257:489;;;162334:29;;;;;;;:25;:29;;;;;;;;162330:267;;;162410:3;162400:7;;162391:6;:16;;;;:::i;:::-;:22;;;;:::i;:::-;162384:29;;162330:267;;;162501:31;;;;;;;:25;:31;;;;;;;;162498:99;;;162578:3;162569:6;;162560;:15;;;;:::i;:::-;:21;;;;:::i;:::-;162553:28;;162498:99;162619:8;;162615:91;;162648:42;162664:4;162678;162685;162648:15;:42::i;:::-;162720:14;162730:4;162720:14;;:::i;:::-;;;162257:489;162756:33;162772:4;162778:2;162782:6;162756:15;:33::i;:::-;160054:2743;;;;159975:2822;;;:::o;134118:471::-;134194:21;134218:19;134231:5;134218:12;:19::i;:::-;134253:7;;134194:43;;-1:-1:-1;134253:7:0;;;104568:6;134253:37;:42;;134252:53;;;;134248:124;;134322:38;;;;;;;;;104568:6;134322:38;;;;;;;;;;;;134248:124;134477:5;134470:13;134463:21;134457:4;134450:35;134563:5;134559:2;134555:14;134551:2;134547:23;134516:29;134510:4;134504;134499:72;134435:147;134118:471;;:::o;73216:360::-;73428:11;73422:18;73412:8;73409:32;73399:159;;73475:10;73469:4;73462:24;73538:4;73532;73525:18;72066:1089;72781:11;73013:16;;72863:26;;;;;;;72973:38;72970:1;;72962:78;73095:27;72066:1089::o;162805:476::-;162895:16;;;162909:1;162895:16;;;;;;;;162871:21;;162895:16;;;;;;;;;;-1:-1:-1;162895:16:0;162871:40;;162940:4;162922;162927:1;162922:7;;;;;;;;:::i;:::-;;;;;;:23;;;;;;;;;;;162966:16;:21;;;:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;162956:4;162961:1;162956:7;;;;;;;;:::i;:::-;;;;;;:33;;;;;;;;;;;163000:63;163017:4;163032:16;163051:11;163000:8;:63::i;:::-;163217:15;;163074:199;;;;;:67;:16;:67;;;;;:199;;163156:11;;163182:1;;163198:4;;163217:15;;;;;163247;;163074:199;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;162860:421;162805:476;:::o;152646:723::-;152702:13;152923:5;152932:1;152923:10;152919:53;;-1:-1:-1;;152950:10:0;;;;;;;;;;;;;;;;;;152646:723::o;152919:53::-;152997:5;152982:12;153038:78;153045:9;;153038:78;;153071:8;;;;:::i;:::-;;-1:-1:-1;153094:10:0;;-1:-1:-1;153102:2:0;153094:10;;:::i;:::-;;;153038:78;;;153126:19;153158:6;153148:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;153148:17:0;;153126:39;;153176:154;153183:10;;153176:154;;153210:11;153220:1;153210:11;;:::i;:::-;;-1:-1:-1;153279:10:0;153287:2;153279:5;:10;:::i;:::-;153266:24;;:2;:24;:::i;:::-;153253:39;;153236:6;153243;153236:14;;;;;;;;:::i;:::-;;;;:56;;;;;;;;;;-1:-1:-1;153307:11:0;153316:2;153307:11;;:::i;:::-;;;153176:154;;;153354:6;152646:723;-1:-1:-1;;;;152646:723:0:o;159647:186::-;159730:31;;;;;;;:25;:31;;;;;;:39;;;;;;;;;;;;;159785:40;;159730:39;;:31;159785:40;;;159647:186;;:::o;123132:4553::-;123225:16;;;123221:52;;123250:23;;;;;;;;;;;;;;123221:52;108134:20;123286:22;123380:18;123393:4;123380:12;:18::i;:::-;123342:56;;123409:33;123445:16;123458:2;123445:12;:16::i;:::-;123409:52;;123474:23;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;123474:23:0;123528:27;;;;;;;;;;123508:17;;;:47;123584:25;;;;;;123566:15;;;:43;123636:13;;;;;;;123620;;;:29;123692:23;;;;;123676:13;;;:39;;;123666:50;;123662:84;;;123725:21;;;;;;;;;;;;;;123662:84;123817:13;;;:23;;;;;;;;;123784:57;;;;;;;;;;;;;;;;;123909:21;;;;;;;123901:39;;123887:11;;;:53;;;123856:85;;;;;;;;;123988:17;;;;123974:57;;124023:7;110771:8;;110696:91;124023:7;124007:1;:13;;;:23;;;;;:::i;:::-;;147852:8;;;147862:9;;147848:24;;147685:205;123974:57;123958:73;;124052:19;;;;;104568:6;124052:49;123958:13;124052:54;124048:250;;124139:2;124131:10;;:4;:10;;;124127:67;;124181:13;;124161:17;;;;:33;124143:15;;;:51;124127:67;124229:53;110771:8;124243:1;:11;;;:21;;;;;:::i;:::-;;124266:1;:15;;;147852:8;;;147862:9;;147848:24;;147685:205;124229:53;124213:13;;;:69;124048:250;124377:13;;124361;;;;124341:16;;;;;;;;;124333:41;;:57;;;124314:16;;;:76;;;124405:43;;;;;;;;;;;124377:13;;124497:48;;124515:29;124497:17;:48::i;:::-;124629:16;;124664:13;;124465:80;;-1:-1:-1;124583:4:0;;;;124629:16;;;;;;;124664:18;124660:1055;;149370:2;149366:10;;;124736:1;149363:23;149356:4;149349:12;;149342:45;124757:20;124780:49;124797:1;:16;;;124815:1;:13;;;124780:16;:49::i;:::-;124878:13;;;124848:27;124878:13;;;:7;;;:13;;;;;124930:17;;;;124996:13;;125028:45;;;124984:25;;;125028:45;;;;;;;;;;;;124757:72;;-1:-1:-1;124878:13:0;;125123:577;125178:11;;;;;144131:1;144127:13;;;144112:2;144108:17;;;144104:37;144225:8;125178:11;;-1:-1:-1;125149:10:0;;144206:1;144202:21;;;;;144198:36;144186:10;144182:53;125149:41;;145125:10;;;145224:1;145220:9;;;145205:2;145201:17;;;145197:33;145341:8;;145395:18;145274:1;145270:17;;;;;;145558:9;;;145547:32;;;;145540:40;;;145533:48;;;145523:59;;125149:41;-1:-1:-1;149667:8:0;;149720:4;149713:12;;;149707:19;149732:1;149728:10;;;149704:35;149689:51;;149798:17;149788:28;;125337:15;125333:120;;;125386:12;;;144492:2;144488:17;144511:1;144507:13;;;144484:37;144636:8;;144561:21;144565:1;144561:21;;;;144764:9;;;144760:21;;144690:10;144753:29;144746:37;;144739:45;144729:56;;125400:16;;;;;125381:48;145889:1;145885:13;;;125484:20;;;145867:2;145863:20;145859:40;145969:8;145955:4;145951:16;;145947:31;145944:1;145940:39;125475:176;;;125543:20;;;146239:2;146235:20;146261:1;146257:13;;;146231:40;146389:8;;146430:13;146315:4;146311:16;;146403:9;146399:14;146385:29;146372:75;;125609:18;;;;:14;;;:18;;;;;125602:25;;;;;;125475:176;125126:544;125691:7;125678:9;:20;125123:577;;124684:1031;;;;124660:1055;125735:13;;;;:18;125731:1458;;149370:2;149366:10;;;149356:4;149349:12;;149342:45;125848:13;;125908:11;;;125826:19;125908:11;;;:7;;;:11;;;;;;;125956:15;;;;126016:13;;;;125848;;;;;;;125908:11;;126006:23;;;;126065:43;126090:13;125908:11;126065:24;:43::i;:::-;126048:60;-1:-1:-1;126127:16:0;110771:8;126146:1;:13;;;:23;;;;;:::i;:::-;126188:41;;;;;;;;;;;;126146:23;;-1:-1:-1;126279:723:0;126305:10;126342:19;;126338:420;;126414:16;;;;;144131:1;144127:13;;;126400:12;;;144112:2;144108:17;144104:37;144225:8;126414:16;;-1:-1:-1;144206:1:0;144202:21;;;;;144198:36;144186:10;144182:53;126390:41;;;;126338:420;;;-1:-1:-1;126493:11:0;126531:135;126538:29;126543:2;143556:5;;;143566:1;143555:12;126547:19;143444:180;126538:29;:34;;;126531:135;;126626:1;126621:6;147289:16;;;147258:24;;147254:33;;;147251:55;126531:135;;;126722:1;126717:6;;147289:16;;;147258:24;;147254:33;;;147251:55;126692:42;;126338:420;144492:2;144488:17;;;144511:1;144507:13;;;144484:37;144636:8;;144561:21;144565:1;144561:21;;;;144764:9;;;144760:21;;144690:10;144753:29;144746:37;;144739:45;144729:56;;145125:10;;;145224:1;145220:9;;;145205:2;145201:17;;;145197:33;145341:8;;145395:18;145486:10;145482:26;;145465:2;145461:19;;;145458:51;145274:1;145270:17;;;;;;145558:9;;;145554:24;;;;145547:32;145540:40;;;145533:48;;;145523:59;;-1:-1:-1;126889:9:0;;;;149667:8;;149720:4;149713:12;;;149707:19;149732:1;149728:10;;;149704:35;149689:51;;149798:17;149788:28;;126282:694;126995:5;126984:7;:16;126279:723;;127160:1;127146:15;;147289:16;;;147258:24;;147254:33;;;147251:55;127112:61;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;125731:1458:0;127209:15;;;;:22;:27;127205:171;;127257:41;;;;;;;;;;;;-1:-1:-1;127345:14:0;;;127317:43;;127333:10;;127345:14;;127317:15;:43::i;:::-;123759:3628;;;127517:6;127511:4;127504:20;127662:2;127658;127654:11;127650:2;127646:20;127638:4;127634:2;127630:13;127626:2;127622:22;127595:25;127589:4;127583;127578:89;127450:228;;;;123132:4553;;;:::o;164787:399::-;164870:4;164826:23;112220:37;;;:30;:37;;;;;:45;;;;;;164826:50;;164891:15;164910:1;164891:20;164887:91;;164960:7;164787:399::o;164887:91::-;165058:18;;165013:15;;165043:33;;165039:99;;;-1:-1:-1;165108:18:0;;165039:99;165148:30;165165:12;165148:16;:30::i;148445:667::-;148505:20;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;148505:20:0;148781:4;148775:11;148813:1;148807:4;148800:15;148874:4;148868;148864:15;148963:1;148960;148956:9;148948:6;148944:22;148938:4;148931:36;149022:4;149018:1;149012:4;149008:12;149001:26;149068:6;149065:1;149058:17;;;148445:667;;;:::o;127758:395::-;127898:4;;128058:1;128023:30;110771:8;128023:20;:30;:::i;:::-;128022:37;;;-1:-1:-1;128136:3:0;128128:11;;128085:31;;;128077:63;:68;;;127758:395;-1:-1:-1;;;;127758:395:0:o;149935:645::-;150110:4;150107:1;150103:12;150097:19;150149:4;150143;150139:15;150208:10;150205:1;150198:21;150283:4;150276;150273:1;150269:12;150262:26;150379:4;150373:11;150370:1;150366:19;150360:4;150356:30;150347:39;;150505:4;150502:1;150499;150492:4;150489:1;150485:12;150482:1;150474:6;150467:5;150462:48;150458:1;150454;150448:8;150445:15;150441:70;150431:131;;150542:4;150539:1;150532:15;150431:131;;;149935:645;;:::o;14:250:1:-;99:1;109:113;123:6;120:1;117:13;109:113;;;199:11;;;193:18;180:11;;;173:39;145:2;138:10;109:113;;;-1:-1:-1;;256:1:1;238:16;;231:27;14:250::o;269:455::-;418:2;407:9;400:21;381:4;450:6;444:13;493:6;488:2;477:9;473:18;466:34;509:79;581:6;576:2;565:9;561:18;556:2;548:6;544:15;509:79;:::i;:::-;640:2;628:15;645:66;624:88;609:104;;;;715:2;605:113;;269:455;-1:-1:-1;;269:455:1:o;729:154::-;815:42;808:5;804:54;797:5;794:65;784:93;;873:1;870;863:12;888:315;956:6;964;1017:2;1005:9;996:7;992:23;988:32;985:52;;;1033:1;1030;1023:12;985:52;1072:9;1059:23;1091:31;1116:5;1091:31;:::i;:::-;1141:5;1193:2;1178:18;;;;1165:32;;-1:-1:-1;;;888:315:1:o;1582:456::-;1659:6;1667;1675;1728:2;1716:9;1707:7;1703:23;1699:32;1696:52;;;1744:1;1741;1734:12;1696:52;1783:9;1770:23;1802:31;1827:5;1802:31;:::i;:::-;1852:5;-1:-1:-1;1909:2:1;1894:18;;1881:32;1922:33;1881:32;1922:33;:::i;:::-;1582:456;;1974:7;;-1:-1:-1;;;2028:2:1;2013:18;;;;2000:32;;1582:456::o;2043:247::-;2102:6;2155:2;2143:9;2134:7;2130:23;2126:32;2123:52;;;2171:1;2168;2161:12;2123:52;2210:9;2197:23;2229:31;2254:5;2229:31;:::i;2295:118::-;2381:5;2374:13;2367:21;2360:5;2357:32;2347:60;;2403:1;2400;2393:12;2418:241;2474:6;2527:2;2515:9;2506:7;2502:23;2498:32;2495:52;;;2543:1;2540;2533:12;2495:52;2582:9;2569:23;2601:28;2623:5;2601:28;:::i;3084:248::-;3152:6;3160;3213:2;3201:9;3192:7;3188:23;3184:32;3181:52;;;3229:1;3226;3219:12;3181:52;-1:-1:-1;;3252:23:1;;;3322:2;3307:18;;;3294:32;;-1:-1:-1;3084:248:1:o;3593:382::-;3658:6;3666;3719:2;3707:9;3698:7;3694:23;3690:32;3687:52;;;3735:1;3732;3725:12;3687:52;3774:9;3761:23;3793:31;3818:5;3793:31;:::i;:::-;3843:5;-1:-1:-1;3900:2:1;3885:18;;3872:32;3913:30;3872:32;3913:30;:::i;:::-;3962:7;3952:17;;;3593:382;;;;;:::o;3980:180::-;4039:6;4092:2;4080:9;4071:7;4067:23;4063:32;4060:52;;;4108:1;4105;4098:12;4060:52;-1:-1:-1;4131:23:1;;3980:180;-1:-1:-1;3980:180:1:o;4165:388::-;4233:6;4241;4294:2;4282:9;4273:7;4269:23;4265:32;4262:52;;;4310:1;4307;4300:12;4262:52;4349:9;4336:23;4368:31;4393:5;4368:31;:::i;:::-;4418:5;-1:-1:-1;4475:2:1;4460:18;;4447:32;4488:33;4447:32;4488:33;:::i;4558:184::-;4610:77;4607:1;4600:88;4707:4;4704:1;4697:15;4731:4;4728:1;4721:15;4747:981;4816:6;4869:2;4857:9;4848:7;4844:23;4840:32;4837:52;;;4885:1;4882;4875:12;4837:52;4925:9;4912:23;4954:18;4995:2;4987:6;4984:14;4981:34;;;5011:1;5008;5001:12;4981:34;5049:6;5038:9;5034:22;5024:32;;5094:7;5087:4;5083:2;5079:13;5075:27;5065:55;;5116:1;5113;5106:12;5065:55;5152:2;5139:16;5174:2;5170;5167:10;5164:36;;;5180:18;;:::i;:::-;5314:2;5308:9;5376:4;5368:13;;5219:66;5364:22;;;5388:2;5360:31;5356:40;5344:53;;;5412:18;;;5432:22;;;5409:46;5406:72;;;5458:18;;:::i;:::-;5498:10;5494:2;5487:22;5533:2;5525:6;5518:18;5573:7;5568:2;5563;5559;5555:11;5551:20;5548:33;5545:53;;;5594:1;5591;5584:12;5545:53;5650:2;5645;5641;5637:11;5632:2;5624:6;5620:15;5607:46;5695:1;5673:15;;;5690:2;5669:24;5662:35;;;;-1:-1:-1;5677:6:1;4747:981;-1:-1:-1;;;;;4747:981:1:o;6084:184::-;6136:77;6133:1;6126:88;6233:4;6230:1;6223:15;6257:4;6254:1;6247:15;6273:168;6346:9;;;6377;;6394:15;;;6388:22;;6374:37;6364:71;;6415:18;;:::i;6446:184::-;6498:77;6495:1;6488:88;6595:4;6592:1;6585:15;6619:4;6616:1;6609:15;6635:120;6675:1;6701;6691:35;;6706:18;;:::i;:::-;-1:-1:-1;6740:9:1;;6635:120::o;6760:112::-;6792:1;6818;6808:35;;6823:18;;:::i;:::-;-1:-1:-1;6857:9:1;;6760:112::o;6877:437::-;6956:1;6952:12;;;;6999;;;7020:61;;7074:4;7066:6;7062:17;7052:27;;7020:61;7127:2;7119:6;7116:14;7096:18;7093:38;7090:218;;7164:77;7161:1;7154:88;7265:4;7262:1;7255:15;7293:4;7290:1;7283:15;7090:218;;6877:437;;;:::o;7445:1246::-;7722:3;7751:1;7784:6;7778:13;7814:36;7840:9;7814:36;:::i;:::-;7869:1;7886:17;;;7912:191;;;;8117:1;8112:358;;;;7879:591;;7912:191;7960:66;7949:9;7945:82;7940:3;7933:95;8083:6;8076:14;8069:22;8061:6;8057:35;8052:3;8048:45;8041:52;;7912:191;;8112:358;8143:6;8140:1;8133:17;8173:4;8218;8215:1;8205:18;8245:1;8259:165;8273:6;8270:1;8267:13;8259:165;;;8351:14;;8338:11;;;8331:35;8394:16;;;;8288:10;;8259:165;;;8263:3;;;8453:6;8448:3;8444:16;8437:23;;7879:591;;;;;8501:6;8495:13;8517:68;8576:8;8571:3;8564:4;8556:6;8552:17;8517:68;:::i;:::-;8648:7;8607:18;;8634:22;;;8683:1;8672:13;;7445:1246;-1:-1:-1;;;;7445:1246:1:o;9350:245::-;9417:6;9470:2;9458:9;9449:7;9445:23;9441:32;9438:52;;;9486:1;9483;9476:12;9438:52;9518:9;9512:16;9537:28;9559:5;9537:28;:::i;10235:306::-;10323:6;10331;10339;10392:2;10380:9;10371:7;10367:23;10363:32;10360:52;;;10408:1;10405;10398:12;10360:52;10437:9;10431:16;10421:26;;10487:2;10476:9;10472:18;10466:25;10456:35;;10531:2;10520:9;10516:18;10510:25;10500:35;;10235:306;;;;;:::o;10546:184::-;10616:6;10669:2;10657:9;10648:7;10644:23;10640:32;10637:52;;;10685:1;10682;10675:12;10637:52;-1:-1:-1;10708:16:1;;10546:184;-1:-1:-1;10546:184:1:o;11080:518::-;11182:2;11177:3;11174:11;11171:421;;;11218:5;11215:1;11208:16;11262:4;11259:1;11249:18;11332:2;11320:10;11316:19;11313:1;11309:27;11303:4;11299:38;11368:4;11356:10;11353:20;11350:47;;;-1:-1:-1;11391:4:1;11350:47;11446:2;11441:3;11437:12;11434:1;11430:20;11424:4;11420:31;11410:41;;11501:81;11519:2;11512:5;11509:13;11501:81;;;11578:1;11564:16;;11545:1;11534:13;11501:81;;;11505:3;;11080:518;;;:::o;11834:1464::-;11960:3;11954:10;11987:18;11979:6;11976:30;11973:56;;;12009:18;;:::i;:::-;12038:97;12128:6;12088:38;12120:4;12114:11;12088:38;:::i;:::-;12082:4;12038:97;:::i;:::-;12190:4;;12247:2;12236:14;;12264:1;12259:782;;;;13085:1;13102:6;13099:89;;;-1:-1:-1;13154:19:1;;;13148:26;13099:89;11740:66;11731:1;11727:11;;;11723:84;11719:89;11709:100;11815:1;11811:11;;;11706:117;13201:81;;12229:1063;;12259:782;7392:1;7385:14;;;7429:4;7416:18;;12307:66;12295:79;;;12472:236;12486:7;12483:1;12480:14;12472:236;;;12575:19;;;12569:26;12554:42;;12667:27;;;;12635:1;12623:14;;;;12502:19;;12472:236;;;12476:3;12736:6;12727:7;12724:19;12721:261;;;12797:19;;;12791:26;12898:66;12880:1;12876:14;;;12892:3;12872:24;12868:97;12864:102;12849:118;12834:134;;12721:261;-1:-1:-1;;;;;13028:1:1;13012:14;;;13008:22;12995:36;;-1:-1:-1;11834:1464:1:o;14886:125::-;14951:9;;;14972:10;;;14969:36;;;14985:18;;:::i;15787:128::-;15854:9;;;15875:11;;;15872:37;;;15889:18;;:::i;15920:184::-;15972:77;15969:1;15962:88;16069:4;16066:1;16059:15;16093:4;16090:1;16083:15;16109:251;16179:6;16232:2;16220:9;16211:7;16207:23;16203:32;16200:52;;;16248:1;16245;16238:12;16200:52;16280:9;16274:16;16299:31;16324:5;16299:31;:::i;16365:1026::-;16627:4;16675:3;16664:9;16660:19;16706:6;16695:9;16688:25;16732:2;16770:6;16765:2;16754:9;16750:18;16743:34;16813:3;16808:2;16797:9;16793:18;16786:31;16837:6;16872;16866:13;16903:6;16895;16888:22;16941:3;16930:9;16926:19;16919:26;;16980:2;16972:6;16968:15;16954:29;;17001:1;17011:218;17025:6;17022:1;17019:13;17011:218;;;17090:13;;17105:42;17086:62;17074:75;;17204:15;;;;17169:12;;;;17047:1;17040:9;17011:218;;;-1:-1:-1;;17297:42:1;17285:55;;;;17280:2;17265:18;;17258:83;-1:-1:-1;;;17372:3:1;17357:19;17350:35;17246:3;16365:1026;-1:-1:-1;;;16365:1026:1:o;17396:195::-;17435:3;17466:66;17459:5;17456:77;17453:103;;17536:18;;:::i;:::-;-1:-1:-1;17583:1:1;17572:13;;17396:195::o

ipfs://3dddf96112529cdfe05c6f175c689882e66380e34b6df96ef55f110412660d2e