Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

import "./DN404.sol";
import "./DN404Mirror.sol";
import {Ownable} from "solady/src/auth/Ownable.sol";
import {LibString} from "solady/src/utils/LibString.sol";
import {SafeTransferLib} from "solady/src/utils/SafeTransferLib.sol";

contract COOL404 is DN404, Ownable {
    string private _name;
    string private _symbol;
    string private _baseURI;

    constructor() {
        _initializeOwner(msg.sender);

        _name = "COOL404";
        _symbol = "COOL404";
        _baseURI = "ipfs://QmSPJ67r1KBjZN99SJcV4D7JFZ3Qks1GPyCoNrfxgFgjrz/";

        address mirror = address(new DN404Mirror(msg.sender));
        _initializeDN404(404 * 10 ** 18, msg.sender, mirror);
    }

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

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

    function tokenURI(
        uint256 tokenId
    ) public view override returns (string memory result) {
        if (bytes(_baseURI).length != 0) {
            result = string(
                abi.encodePacked(_baseURI, LibString.toString(tokenId))
            );
        }
    }

    function setBaseURI(string calldata baseURI_) public onlyOwner {
        _baseURI = baseURI_;
    }

    function withdraw() public onlyOwner {
        SafeTransferLib.safeTransferAllETH(msg.sender);
    }
}

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

/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/SafeTransferLib.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SafeTransferLib.sol)
///
/// @dev Note:
/// - For ETH transfers, please use `forceSafeTransferETH` for DoS protection.
/// - For ERC20s, this implementation won't check that a token has code,
///   responsibility is delegated to the caller.
library SafeTransferLib {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The ETH transfer has failed.
    error ETHTransferFailed();

    /// @dev The ERC20 `transferFrom` has failed.
    error TransferFromFailed();

    /// @dev The ERC20 `transfer` has failed.
    error TransferFailed();

    /// @dev The ERC20 `approve` has failed.
    error ApproveFailed();

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

    /// @dev Suggested gas stipend for contract receiving ETH that disallows any storage writes.
    uint256 internal constant GAS_STIPEND_NO_STORAGE_WRITES = 2300;

    /// @dev Suggested gas stipend for contract receiving ETH to perform a few
    /// storage reads and writes, but low enough to prevent griefing.
    uint256 internal constant GAS_STIPEND_NO_GRIEF = 100000;

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

    // If the ETH transfer MUST succeed with a reasonable gas budget, use the force variants.
    //
    // The regular variants:
    // - Forwards all remaining gas to the target.
    // - Reverts if the target reverts.
    // - Reverts if the current contract has insufficient balance.
    //
    // The force variants:
    // - Forwards with an optional gas stipend
    //   (defaults to `GAS_STIPEND_NO_GRIEF`, which is sufficient for most cases).
    // - If the target reverts, or if the gas stipend is exhausted,
    //   creates a temporary contract to force send the ETH via `SELFDESTRUCT`.
    //   Future compatible with `SENDALL`: https://eips.ethereum.org/EIPS/eip-4758.
    // - Reverts if the current contract has insufficient balance.
    //
    // The try variants:
    // - Forwards with a mandatory gas stipend.
    // - Instead of reverting, returns whether the transfer succeeded.

    /// @dev Sends `amount` (in wei) ETH to `to`.
    function safeTransferETH(address to, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            if iszero(call(gas(), to, amount, codesize(), 0x00, codesize(), 0x00)) {
                mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.
                revert(0x1c, 0x04)
            }
        }
    }

    /// @dev Sends all the ETH in the current contract to `to`.
    function safeTransferAllETH(address to) internal {
        /// @solidity memory-safe-assembly
        assembly {
            // Transfer all the ETH and check if it succeeded or not.
            if iszero(call(gas(), to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {
                mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.
                revert(0x1c, 0x04)
            }
        }
    }

    /// @dev Force sends `amount` (in wei) ETH to `to`, with a `gasStipend`.
    function forceSafeTransferETH(address to, uint256 amount, uint256 gasStipend) internal {
        /// @solidity memory-safe-assembly
        assembly {
            if lt(selfbalance(), amount) {
                mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.
                revert(0x1c, 0x04)
            }
            if iszero(call(gasStipend, to, amount, codesize(), 0x00, codesize(), 0x00)) {
                mstore(0x00, to) // Store the address in scratch space.
                mstore8(0x0b, 0x73) // Opcode `PUSH20`.
                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.
                if iszero(create(amount, 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.
            }
        }
    }

    /// @dev Force sends all the ETH in the current contract to `to`, with a `gasStipend`.
    function forceSafeTransferAllETH(address to, uint256 gasStipend) internal {
        /// @solidity memory-safe-assembly
        assembly {
            if iszero(call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {
                mstore(0x00, to) // Store the address in scratch space.
                mstore8(0x0b, 0x73) // Opcode `PUSH20`.
                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.
                if iszero(create(selfbalance(), 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.
            }
        }
    }

    /// @dev Force sends `amount` (in wei) ETH to `to`, with `GAS_STIPEND_NO_GRIEF`.
    function forceSafeTransferETH(address to, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            if lt(selfbalance(), amount) {
                mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.
                revert(0x1c, 0x04)
            }
            if iszero(call(GAS_STIPEND_NO_GRIEF, to, amount, codesize(), 0x00, codesize(), 0x00)) {
                mstore(0x00, to) // Store the address in scratch space.
                mstore8(0x0b, 0x73) // Opcode `PUSH20`.
                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.
                if iszero(create(amount, 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.
            }
        }
    }

    /// @dev Force sends all the ETH in the current contract to `to`, with `GAS_STIPEND_NO_GRIEF`.
    function forceSafeTransferAllETH(address to) internal {
        /// @solidity memory-safe-assembly
        assembly {
            // forgefmt: disable-next-item
            if iszero(call(GAS_STIPEND_NO_GRIEF, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {
                mstore(0x00, to) // Store the address in scratch space.
                mstore8(0x0b, 0x73) // Opcode `PUSH20`.
                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.
                if iszero(create(selfbalance(), 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.
            }
        }
    }

    /// @dev Sends `amount` (in wei) ETH to `to`, with a `gasStipend`.
    function trySafeTransferETH(address to, uint256 amount, uint256 gasStipend)
        internal
        returns (bool success)
    {
        /// @solidity memory-safe-assembly
        assembly {
            success := call(gasStipend, to, amount, codesize(), 0x00, codesize(), 0x00)
        }
    }

    /// @dev Sends all the ETH in the current contract to `to`, with a `gasStipend`.
    function trySafeTransferAllETH(address to, uint256 gasStipend)
        internal
        returns (bool success)
    {
        /// @solidity memory-safe-assembly
        assembly {
            success := call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)
        }
    }

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

    /// @dev Sends `amount` of ERC20 `token` from `from` to `to`.
    /// Reverts upon failure.
    ///
    /// The `from` account must have at least `amount` approved for
    /// the current contract to manage.
    function safeTransferFrom(address token, address from, address to, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            let m := mload(0x40) // Cache the free memory pointer.
            mstore(0x60, amount) // Store the `amount` argument.
            mstore(0x40, to) // Store the `to` argument.
            mstore(0x2c, shl(96, from)) // Store the `from` argument.
            mstore(0x0c, 0x23b872dd000000000000000000000000) // `transferFrom(address,address,uint256)`.
            // Perform the transfer, reverting upon failure.
            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
                    call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
                )
            ) {
                mstore(0x00, 0x7939f424) // `TransferFromFailed()`.
                revert(0x1c, 0x04)
            }
            mstore(0x60, 0) // Restore the zero slot to zero.
            mstore(0x40, m) // Restore the free memory pointer.
        }
    }

    /// @dev Sends all of ERC20 `token` from `from` to `to`.
    /// Reverts upon failure.
    ///
    /// The `from` account must have their entire balance approved for
    /// the current contract to manage.
    function safeTransferAllFrom(address token, address from, address to)
        internal
        returns (uint256 amount)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let m := mload(0x40) // Cache the free memory pointer.
            mstore(0x40, to) // Store the `to` argument.
            mstore(0x2c, shl(96, from)) // Store the `from` argument.
            mstore(0x0c, 0x70a08231000000000000000000000000) // `balanceOf(address)`.
            // Read the balance, reverting upon failure.
            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    gt(returndatasize(), 0x1f), // At least 32 bytes returned.
                    staticcall(gas(), token, 0x1c, 0x24, 0x60, 0x20)
                )
            ) {
                mstore(0x00, 0x7939f424) // `TransferFromFailed()`.
                revert(0x1c, 0x04)
            }
            mstore(0x00, 0x23b872dd) // `transferFrom(address,address,uint256)`.
            amount := mload(0x60) // The `amount` is already at 0x60. We'll need to return it.
            // Perform the transfer, reverting upon failure.
            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
                    call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
                )
            ) {
                mstore(0x00, 0x7939f424) // `TransferFromFailed()`.
                revert(0x1c, 0x04)
            }
            mstore(0x60, 0) // Restore the zero slot to zero.
            mstore(0x40, m) // Restore the free memory pointer.
        }
    }

    /// @dev Sends `amount` of ERC20 `token` from the current contract to `to`.
    /// Reverts upon failure.
    function safeTransfer(address token, address to, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x14, to) // Store the `to` argument.
            mstore(0x34, amount) // Store the `amount` argument.
            mstore(0x00, 0xa9059cbb000000000000000000000000) // `transfer(address,uint256)`.
            // Perform the transfer, reverting upon failure.
            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
                    call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
                )
            ) {
                mstore(0x00, 0x90b8ec18) // `TransferFailed()`.
                revert(0x1c, 0x04)
            }
            mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.
        }
    }

    /// @dev Sends all of ERC20 `token` from the current contract to `to`.
    /// Reverts upon failure.
    function safeTransferAll(address token, address to) internal returns (uint256 amount) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, 0x70a08231) // Store the function selector of `balanceOf(address)`.
            mstore(0x20, address()) // Store the address of the current contract.
            // Read the balance, reverting upon failure.
            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    gt(returndatasize(), 0x1f), // At least 32 bytes returned.
                    staticcall(gas(), token, 0x1c, 0x24, 0x34, 0x20)
                )
            ) {
                mstore(0x00, 0x90b8ec18) // `TransferFailed()`.
                revert(0x1c, 0x04)
            }
            mstore(0x14, to) // Store the `to` argument.
            amount := mload(0x34) // The `amount` is already at 0x34. We'll need to return it.
            mstore(0x00, 0xa9059cbb000000000000000000000000) // `transfer(address,uint256)`.
            // Perform the transfer, reverting upon failure.
            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
                    call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
                )
            ) {
                mstore(0x00, 0x90b8ec18) // `TransferFailed()`.
                revert(0x1c, 0x04)
            }
            mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.
        }
    }

    /// @dev Sets `amount` of ERC20 `token` for `to` to manage on behalf of the current contract.
    /// Reverts upon failure.
    function safeApprove(address token, address to, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x14, to) // Store the `to` argument.
            mstore(0x34, amount) // Store the `amount` argument.
            mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.
            // Perform the approval, reverting upon failure.
            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
                    call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
                )
            ) {
                mstore(0x00, 0x3e3f8f73) // `ApproveFailed()`.
                revert(0x1c, 0x04)
            }
            mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.
        }
    }

    /// @dev Sets `amount` of ERC20 `token` for `to` to manage on behalf of the current contract.
    /// If the initial attempt to approve fails, attempts to reset the approved amount to zero,
    /// then retries the approval again (some tokens, e.g. USDT, requires this).
    /// Reverts upon failure.
    function safeApproveWithRetry(address token, address to, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x14, to) // Store the `to` argument.
            mstore(0x34, amount) // Store the `amount` argument.
            mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.
            // Perform the approval, retrying upon failure.
            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
                    call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
                )
            ) {
                mstore(0x34, 0) // Store 0 for the `amount`.
                mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.
                pop(call(gas(), token, 0, 0x10, 0x44, codesize(), 0x00)) // Reset the approval.
                mstore(0x34, amount) // Store back the original `amount`.
                // Retry the approval, reverting upon failure.
                if iszero(
                    and(
                        or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
                        call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
                    )
                ) {
                    mstore(0x00, 0x3e3f8f73) // `ApproveFailed()`.
                    revert(0x1c, 0x04)
                }
            }
            mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.
        }
    }

    /// @dev Returns the amount of ERC20 `token` owned by `account`.
    /// Returns zero if the `token` does not exist.
    function balanceOf(address token, address account) internal view returns (uint256 amount) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x14, account) // Store the `account` argument.
            mstore(0x00, 0x70a08231000000000000000000000000) // `balanceOf(address)`.
            amount :=
                mul(
                    mload(0x20),
                    and( // The arguments of `and` are evaluated from right to left.
                        gt(returndatasize(), 0x1f), // At least 32 bytes returned.
                        staticcall(gas(), token, 0x10, 0x24, 0x20, 0x20)
                    )
                )
        }
    }
}

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

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

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

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

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         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)
        }
    }
}

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

/// @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();
        _;
    }
}

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

/// @title DN404Mirror
/// @notice DN404Mirror 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 DN404Mirror {
    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                           EVENTS                           */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

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

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

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

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

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

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

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                        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;
    }

    /// @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) {
        address base = baseERC20();
        /// @solidity memory-safe-assembly
        assembly {
            result := mload(0x40)
            mstore(0x00, 0x06fdde03) // `name()`.
            if iszero(staticcall(gas(), base, 0x1c, 0x04, 0x00, 0x00)) {
                returndatacopy(result, 0x00, returndatasize())
                revert(result, returndatasize())
            }
            returndatacopy(0x00, 0x00, 0x20)
            returndatacopy(result, mload(0x00), 0x20)
            returndatacopy(add(result, 0x20), add(mload(0x00), 0x20), mload(result))
            mstore(0x40, add(add(result, 0x20), mload(result)))
        }
    }

    /// @dev Returns the token collection symbol from the base DN404 contract.
    function symbol() public view virtual returns (string memory result) {
        address base = baseERC20();
        /// @solidity memory-safe-assembly
        assembly {
            result := mload(0x40)
            mstore(0x00, 0x95d89b41) // `symbol()`.
            if iszero(staticcall(gas(), base, 0x1c, 0x04, 0x00, 0x00)) {
                returndatacopy(result, 0x00, returndatasize())
                revert(result, returndatasize())
            }
            returndatacopy(0x00, 0x00, 0x20)
            returndatacopy(result, mload(0x00), 0x20)
            returndatacopy(add(result, 0x20), add(mload(0x00), 0x20), mload(result))
            mstore(0x40, add(add(result, 0x20), mload(result)))
        }
    }

    /// @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) {
        address base = baseERC20();
        /// @solidity memory-safe-assembly
        assembly {
            result := mload(0x40)
            mstore(0x20, id)
            mstore(0x00, 0xc87b56dd) // `tokenURI()`.
            if iszero(staticcall(gas(), base, 0x1c, 0x24, 0x00, 0x00)) {
                returndatacopy(result, 0x00, returndatasize())
                revert(result, returndatasize())
            }
            returndatacopy(0x00, 0x00, 0x20)
            returndatacopy(result, mload(0x00), 0x20)
            returndatacopy(add(result, 0x20), add(mload(0x00), 0x20), mload(result))
            mstore(0x40, add(add(result, 0x20), mload(result)))
        }
    }

    /// @dev Returns the total NFT supply from the base DN404 contract.
    function totalSupply() public view virtual returns (uint256 result) {
        address base = baseERC20();
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, 0xe2c79281) // `totalNFTSupply()`.
            if iszero(
                and(gt(returndatasize(), 0x1f), staticcall(gas(), base, 0x1c, 0x04, 0x00, 0x20))
            ) {
                returndatacopy(mload(0x40), 0x00, returndatasize())
                revert(mload(0x40), returndatasize())
            }
            result := mload(0x00)
        }
    }

    /// @dev Returns the number of NFT tokens owned by `owner` from the base DN404 contract.
    ///
    /// Requirements:
    /// - `owner` must not be the zero address.
    function balanceOf(address owner) public view virtual returns (uint256 result) {
        address base = baseERC20();
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, shr(96, shl(96, owner)))
            mstore(0x00, 0xf5b100ea) // `balanceOfNFT(address)`.
            if iszero(
                and(gt(returndatasize(), 0x1f), staticcall(gas(), base, 0x1c, 0x24, 0x00, 0x20))
            ) {
                returndatacopy(mload(0x40), 0x00, returndatasize())
                revert(mload(0x40), returndatasize())
            }
            result := mload(0x00)
        }
    }

    /// @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) {
        address base = baseERC20();
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, 0x6352211e) // `ownerOf(uint256)`.
            mstore(0x20, id)
            if iszero(
                and(gt(returndatasize(), 0x1f), staticcall(gas(), base, 0x1c, 0x24, 0x00, 0x20))
            ) {
                returndatacopy(mload(0x40), 0x00, returndatasize())
                revert(mload(0x40), returndatasize())
            }
            result := shr(96, mload(0x0c))
        }
    }

    /// @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 result) {
        address base = baseERC20();
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, 0x081812fc) // `getApproved(uint256)`.
            mstore(0x20, id)
            if iszero(
                and(gt(returndatasize(), 0x1f), staticcall(gas(), base, 0x1c, 0x24, 0x00, 0x20))
            ) {
                returndatacopy(mload(0x40), 0x00, returndatasize())
                revert(mload(0x40), returndatasize())
            }
            result := shr(96, mload(0x0c))
        }
    }

    /// @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.
            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 `owner` from
    /// the base DN404 contract.
    function isApprovedForAll(address owner, address operator)
        public
        view
        virtual
        returns (bool result)
    {
        address base = baseERC20();
        /// @solidity memory-safe-assembly
        assembly {
            let m := mload(0x40)
            mstore(0x40, operator)
            mstore(0x2c, shl(96, owner))
            mstore(0x0c, 0xe985e9c5000000000000000000000000) // `isApprovedForAll(address,address)`.
            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 := iszero(iszero(mload(0x00)))
        }
    }

    /// @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))
        }
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                     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),
                        mul(a, iszero(b)),
                        shr(168, shl(160, d))
                    )
                }
                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 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)
            }
        }
    }
}

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

/// @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
///   DN404Mirror contract ***MUST*** be deployed and linked during
///   initialization.
abstract contract DN404 {
    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                           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);

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                        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 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 an non-existent NFT.
    error TokenDoesNotExist();

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

    /// @dev Amount of token balance that is equal to one NFT.
    uint256 internal constant _WAD = 10 ** 18;

    /// @dev The maximum token ID allowed for an NFT.
    uint256 internal constant _MAX_TOKEN_ID = 0xffffffff;

    /// @dev The maximum possible token supply.
    uint256 internal constant _MAX_SUPPLY = 10 ** 18 * 0xffffffff - 1;

    /// @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;

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                          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 {
        mapping(uint256 => uint256) map;
    }

    /// @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 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.
        mapping(address => mapping(address => bool)) operatorApprovals;
        // Mapping of NFT token approvals to approved operators.
        mapping(uint256 => address) tokenApprovals;
        // Mapping of user allowances for token spenders.
        mapping(address => mapping(address => uint256)) allowance;
        // Mapping of NFT token IDs owned by an address.
        mapping(address => Uint32Map) owned;
        // 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();
        _linkMirrorContract(mirror);

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

        if (initialTokenSupply > 0) {
            if (initialSupplyOwner == address(0)) revert TransferToZeroAddress();
            if (initialTokenSupply > _MAX_SUPPLY) revert TotalSupplyOverflow();

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

            emit Transfer(address(0), initialSupplyOwner, initialTokenSupply);

            _setSkipNFT(initialSupplyOwner, true);
        }
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*               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) {
        return _getDN404Storage().allowance[owner][spender];
    }

    /// @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) {
        DN404Storage storage $ = _getDN404Storage();

        $.allowance[msg.sender][spender] = amount;

        emit Approval(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) {
        DN404Storage storage $ = _getDN404Storage();

        uint256 allowed = $.allowance[from][msg.sender];

        if (allowed != type(uint256).max) {
            if (amount > allowed) revert InsufficientAllowance();
            unchecked {
                $.allowance[from][msg.sender] = allowed - amount;
            }
        }

        _transfer(from, to, amount);

        return true;
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                  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 currentTokenSupply = uint256($.totalSupply) + amount;
            if (amount > _MAX_SUPPLY || currentTokenSupply > _MAX_SUPPLY) {
                revert TotalSupplyOverflow();
            }
            $.totalSupply = uint96(currentTokenSupply);

            uint256 toBalance = toAddressData.balance + amount;
            toAddressData.balance = uint96(toBalance);

            if (toAddressData.flags & _ADDRESS_DATA_SKIP_NFT_FLAG == 0) {
                Uint32Map storage toOwned = $.owned[to];
                uint256 toIndex = toAddressData.ownedLength;
                uint256 toEnd = toBalance / _WAD;
                _PackedLogs memory packedLogs = _packedLogsMalloc(_zeroFloorSub(toEnd, toIndex));

                if (packedLogs.logs.length != 0) {
                    uint256 maxNFTId = $.totalSupply / _WAD;
                    uint32 toAlias = _registerAndResolveAlias(toAddressData, to);
                    uint256 id = $.nextTokenId;
                    $.totalNFTSupply += uint32(packedLogs.logs.length);
                    toAddressData.ownedLength = uint32(toEnd);
                    // Mint loop.
                    do {
                        while (_get($.oo, _ownershipIndex(id)) != 0) {
                            if (++id > maxNFTId) id = 1;
                        }
                        _set(toOwned, toIndex, uint32(id));
                        _setOwnerAliasAndOwnedIndex($.oo, id, toAlias, uint32(toIndex++));
                        _packedLogsAppend(packedLogs, to, id, 0);
                        if (++id > maxNFTId) id = 1;
                    } while (toIndex != toEnd);
                    $.nextTokenId = uint32(id);
                    _packedLogsSend(packedLogs, $.mirrorERC721);
                }
            }
        }
        emit Transfer(address(0), to, amount);
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                  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();

        uint256 currentTokenSupply = $.totalSupply;

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

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

            if (nftAmountToBurn != 0) {
                $.totalNFTSupply -= uint32(nftAmountToBurn);

                _PackedLogs memory packedLogs = _packedLogsMalloc(nftAmountToBurn);

                uint256 fromEnd = fromIndex - nftAmountToBurn;
                // Burn loop.
                do {
                    uint256 id = _get(fromOwned, --fromIndex);
                    _setOwnerAliasAndOwnedIndex($.oo, id, 0, 0);
                    delete $.tokenApprovals[id];
                    _packedLogsAppend(packedLogs, from, id, 1);
                } while (fromIndex != fromEnd);

                fromAddressData.ownedLength = uint32(fromIndex);
                _packedLogsSend(packedLogs, $.mirrorERC721);
            }
        }
        emit Transfer(from, address(0), amount);
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                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.fromBalance = fromAddressData.balance;

        if (amount > t.fromBalance) revert InsufficientBalance();

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

            t.nftAmountToBurn = _zeroFloorSub(t.fromOwnedLength, t.fromBalance / _WAD);

            if (toAddressData.flags & _ADDRESS_DATA_SKIP_NFT_FLAG == 0) {
                if (from == to) t.toOwnedLength = t.fromOwnedLength - t.nftAmountToBurn;
                t.nftAmountToMint = _zeroFloorSub(t.toBalance / _WAD, t.toOwnedLength);
            }

            _PackedLogs memory packedLogs = _packedLogsMalloc(t.nftAmountToBurn + t.nftAmountToMint);

            if (t.nftAmountToBurn != 0) {
                Uint32Map storage fromOwned = $.owned[from];
                uint256 fromIndex = t.fromOwnedLength;
                uint256 fromEnd = fromIndex - t.nftAmountToBurn;
                $.totalNFTSupply -= uint32(t.nftAmountToBurn);
                fromAddressData.ownedLength = uint32(fromEnd);
                // Burn loop.
                do {
                    uint256 id = _get(fromOwned, --fromIndex);
                    _setOwnerAliasAndOwnedIndex($.oo, id, 0, 0);
                    delete $.tokenApprovals[id];
                    _packedLogsAppend(packedLogs, from, id, 1);
                } while (fromIndex != fromEnd);
            }

            if (t.nftAmountToMint != 0) {
                Uint32Map storage toOwned = $.owned[to];
                uint256 toIndex = t.toOwnedLength;
                uint256 toEnd = toIndex + t.nftAmountToMint;
                uint32 toAlias = _registerAndResolveAlias(toAddressData, to);
                uint256 maxNFTId = $.totalSupply / _WAD;
                uint256 id = $.nextTokenId;
                $.totalNFTSupply += uint32(t.nftAmountToMint);
                toAddressData.ownedLength = uint32(toEnd);
                // Mint loop.
                do {
                    while (_get($.oo, _ownershipIndex(id)) != 0) {
                        if (++id > maxNFTId) id = 1;
                    }
                    _set(toOwned, toIndex, uint32(id));
                    _setOwnerAliasAndOwnedIndex($.oo, id, toAlias, uint32(toIndex++));
                    _packedLogsAppend(packedLogs, to, id, 0);
                    if (++id > maxNFTId) id = 1;
                } while (toIndex != toEnd);
                $.nextTokenId = uint32(id);
            }

            if (packedLogs.logs.length != 0) {
                _packedLogsSend(packedLogs, $.mirrorERC721);
            }
        }
        emit Transfer(from, to, amount);
    }

    /// @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();

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

        if (from != owner) revert TransferFromIncorrectOwner();

        if (msgSender != from) {
            if (!$.operatorApprovals[from][msgSender]) {
                if (msgSender != $.tokenApprovals[id]) {
                    revert TransferCallerNotOwnerNorApproved();
                }
            }
        }

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

        fromAddressData.balance -= uint96(_WAD);

        unchecked {
            toAddressData.balance += uint96(_WAD);

            _set($.oo, _ownershipIndex(id), _registerAndResolveAlias(toAddressData, to));
            delete $.tokenApprovals[id];

            uint256 updatedId = _get($.owned[from], --fromAddressData.ownedLength);
            _set($.owned[from], _get($.oo, _ownedIndex(id)), uint32(updatedId));

            uint256 n = toAddressData.ownedLength++;
            _set($.oo, _ownedIndex(updatedId), _get($.oo, _ownedIndex(id)));
            _set($.owned[to], n, uint32(id));
            _set($.oo, _ownedIndex(id), uint32(n));
        }

        emit Transfer(from, to, _WAD);
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                 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 account `a` will skip NFT minting on token mints and transfers.
    /// Returns false if account `a` will mint NFTs on token mints and transfers.
    function getSkipNFT(address a) public view virtual returns (bool) {
        AddressData storage d = _getDN404Storage().addressData[a];
        if (d.flags & _ADDRESS_DATA_INITIALIZED_FLAG == 0) return _hasCode(a);
        return d.flags & _ADDRESS_DATA_SKIP_NFT_FLAG != 0;
    }

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

    /// @dev Internal function to set account `a` skipNFT flag to `state`
    ///
    /// Initializes account `a` AddressData if it is not currently initialized.
    ///
    /// Emits a {SkipNFTSet} event.
    function _setSkipNFT(address a, bool state) internal virtual {
        AddressData storage d = _addressData(a);
        if ((d.flags & _ADDRESS_DATA_SKIP_NFT_FLAG != 0) != state) {
            d.flags ^= _ADDRESS_DATA_SKIP_NFT_FLAG;
        }
        emit SkipNFTSet(a, state);
    }

    /// @dev Returns a storage data pointer for account `a` AddressData
    ///
    /// Initializes account `a` AddressData if it is not currently initialized.
    function _addressData(address a) internal virtual returns (AddressData storage d) {
        DN404Storage storage $ = _getDN404Storage();
        d = $.addressData[a];

        if (d.flags & _ADDRESS_DATA_INITIALIZED_FLAG == 0) {
            uint8 flags = _ADDRESS_DATA_INITIALIZED_FLAG;
            if (_hasCode(a)) flags |= _ADDRESS_DATA_SKIP_NFT_FLAG;
            d.flags = flags;
        }
    }

    /// @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) {
            addressAlias = ++$.numAliases;
            toAddressData.addressAlias = addressAlias;
            $.aliasToAddress[addressAlias] = to;
        }
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                     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().tokenApprovals[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)
    {
        DN404Storage storage $ = _getDN404Storage();

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

        if (msgSender != owner) {
            if (!$.operatorApprovals[owner][msgSender]) {
                revert ApprovalCallerNotOwnerNorApproved();
            }
        }

        $.tokenApprovals[id] = spender;

        return owner;
    }

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

    /// @dev Calls the mirror contract to link it to this contract.
    ///
    /// Reverts if the call to the mirror contract reverts.
    function _linkMirrorContract(address mirror) internal virtual {
        /// @solidity memory-safe-assembly
        assembly {
            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)
            }
        }
    }

    /// @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;

        // `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($.operatorApprovals[owner][operator] ? 1 : 0);
        }
        // `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)));
        }
        // `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);
        }
        // `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 {}

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

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

    /// @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 {
            let logs := add(mload(0x40), 0x40) // Offset by 2 words for `_packedLogsSend`.
            mstore(logs, n)
            let offset := add(0x20, logs)
            mstore(0x40, add(offset, shl(5, n)))
            mstore(p, logs)
            mstore(add(0x20, p), offset)
        }
    }

    /// @dev Adds a packed log item to `p` with address `a`, token `id` and burn flag `burnBit`.
    function _packedLogsAppend(_PackedLogs memory p, address a, uint256 id, uint256 burnBit)
        private
        pure
    {
        /// @solidity memory-safe-assembly
        assembly {
            let offset := mload(add(0x20, p))
            mstore(offset, or(or(shl(96, a), shl(8, id)), burnBit))
            mstore(add(0x20, 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(p)
            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 nftAmountToBurn;
        uint256 nftAmountToMint;
        uint256 fromBalance;
        uint256 toBalance;
        uint256 fromOwnedLength;
        uint256 toOwnedLength;
    }

    /// @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)
        }
    }

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

    /// @dev Returns `i << 1`.
    function _ownershipIndex(uint256 i) private pure returns (uint256) {
        return i << 1;
    }

    /// @dev Returns `(i << 1) + 1`.
    function _ownedIndex(uint256 i) private pure returns (uint256) {
        unchecked {
            return (i << 1) + 1;
        }
    }

    /// @dev Returns the uint32 value at `index` in `map`.
    function _get(Uint32Map storage map, uint256 index) private 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) private {
        /// @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 Sets the owner alias and the owned index together.
    function _setOwnerAliasAndOwnedIndex(
        Uint32Map storage map,
        uint256 id,
        uint32 ownership,
        uint32 ownedIndex
    ) private {
        /// @solidity memory-safe-assembly
        assembly {
            let value := or(shl(32, ownedIndex), and(0xffffffff, ownership))
            mstore(0x20, map.slot)
            mstore(0x00, shr(2, id))
            let s := keccak256(0x00, 0x40) // Storage slot.
            let o := shl(6, and(id, 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)))))
        }
    }
}

{
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "remappings": []
}

• 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":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"inputs":[],"name":"Unauthorized","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":"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":"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":[{"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":"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":"a","type":"address"}],"name":"getSkipNFT","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"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":[],"name":"renounceOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"requestOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI_","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"skipNFT","type":"bool"}],"name":"setSkipNFT","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"result","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

289:1136:2:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29731:22:0;29756:18;:16;:18::i;:::-;29731:43;;29785:18;29829:3;29806:19;29820:4;29806:13;:19::i;:::-;:26;;29785:47;;29909:10;29895;:24;29891:369;;29953:1;:14;;;;;;;;;;;;29939:28;;:10;:28;;;29935:58;;29976:17;;;;;;;;;;;;;;29935:58;30029:4;30011:8;;:15;;:22;30007:36;;;30035:8;;;30007:36;30058:13;30090:19;30104:4;30090:13;:19::i;:::-;30058:53;;30125:16;30160:19;30174:4;30160:13;:19::i;:::-;30125:56;;30196:53;30204:1;:19;;:26;30224:5;30204:26;;;;;;;;;;;;;;;:36;30231:8;30204:36;;;;;;;;;;;;;;;;;;;;;;;;;:44;;30247:1;30204:44;;;30243:1;30204:44;30196:53;;:7;:53::i;:::-;29921:339;;29891:369;30318:10;30304;:24;30300:255;;30362:1;:14;;;;;;;;;;;;30348:28;;:10;:28;;;30344:58;;30385:17;;;;;;;;;;;;;;30344:58;30438:4;30420:8;;:15;;:22;30416:36;;;30444:8;;;30416:36;30467:10;30480:19;30494:4;30480:13;:19::i;:::-;30467:32;;30514:30;30530:12;30539:2;30530:8;:12::i;:::-;30514:30;;:7;:30::i;:::-;30330:225;30300:255;30645:10;30631;:24;30627:491;;30689:1;:14;;;;;;;;;;;;30675:28;;:10;:28;;;30671:58;;30712:17;;;;;;;;;;;;;;30671:58;30765:4;30747:8;;:15;;:22;30743:36;;;30771:8;;;30743:36;30794:12;30825:19;30839:4;30825:13;:19::i;:::-;30794:52;;30860:10;30889:19;30903:4;30889:13;:19::i;:::-;30860:50;;30924:10;30937:19;30951:4;30937:13;:19::i;:::-;30924:32;;30970:17;31006:19;31020:4;31006:13;:19::i;:::-;30970:57;;31042:41;31059:4;31065:2;31069;31073:9;31042:16;:41::i;:::-;31097:10;31105:1;31097:7;:10::i;:::-;30657:461;;;;30627:491;31199:10;31185;:24;31181:441;;31243:1;:14;;;;;;;;;;;;31229:28;;:10;:28;;;31225:58;;31266:17;;;;;;;;;;;;;;31225:58;31319:4;31301:8;;:15;;:22;31297:36;;;31325:8;;;31297:36;31348:15;31382:19;31396:4;31382:13;:19::i;:::-;31348:55;;31417:11;31454:1;31431:19;31445:4;31431:13;:19::i;:::-;:24;;31417:38;;31469:17;31505:19;31519:4;31505:13;:19::i;:::-;31469:57;;31541:46;31560:7;31569:6;31577:9;31541:18;:46::i;:::-;31601:10;31609:1;31601:7;:10::i;:::-;31211:411;;;31181:441;31699:10;31685;:24;31681:418;;31743:1;:14;;;;;;;;;;;;31729:28;;:10;:28;;;31725:58;;31766:17;;;;;;;;;;;;;;31725:58;31819:4;31801:8;;:15;;:22;31797:36;;;31825:8;;;31797:36;31848:15;31882:19;31896:4;31882:13;:19::i;:::-;31848:55;;31917:10;31930:19;31944:4;31930:13;:19::i;:::-;31917:32;;31963:17;31999:19;32013:4;31999:13;:19::i;:::-;31963:57;;32035:53;32051:35;32063:7;32072:2;32076:9;32051:11;:35::i;:::-;32035:53;;:7;:53::i;:::-;31711:388;;;31681:418;32161:10;32147;:24;32143:259;;32205:1;:14;;;;;;;;;;;;32191:28;;:10;:28;;;32187:58;;32228:17;;;;;;;;;;;;;;32187:58;32281:4;32263:8;;:15;;:22;32259:36;;;32287:8;;;32259:36;32310:10;32323:19;32337:4;32323:13;:19::i;:::-;32310:32;;32357:34;32373:16;32386:2;32373:12;:16::i;:::-;32357:34;;:7;:34::i;:::-;32173:229;32143:259;32465:10;32451;:24;32447:275;;32509:1;:14;;;;;;;;;;;;32495:28;;:10;:28;;;32491:58;;32532:17;;;;;;;;;;;;;;32491:58;32585:4;32567:8;;:15;;:22;32563:36;;;32591:8;;;32563:36;32614:13;32646:19;32660:4;32646:13;:19::i;:::-;32614:53;;32682:29;32690:20;32704:5;32690:13;:20::i;:::-;32682:7;:29::i;:::-;32477:245;32447:275;32780:10;32766;:24;32762:204;;32824:1;:14;;;;;;;;;;;;32810:28;;:10;:28;;;32806:58;;32847:17;;;;;;;;;;;;;;32806:58;32900:4;32882:8;;:15;;:22;32878:36;;;32906:8;;;32878:36;32929:26;32937:17;:15;:17::i;:::-;32929:7;:26::i;:::-;32762:204;33025:10;33011;:24;33007:65;;33051:10;33059:1;33051:7;:10::i;:::-;33007:65;29721:3368;739:90:2;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9732:267:0;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9026:124;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;11323:497;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9021:617:3;;;:::i;:::-;;23823:278:0;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;24208:98;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;8890:74;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1323:100:2;;;;;;;;;;;;;:::i;:::-;;26318:117:0;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9720:456:3;;;:::i;:::-;;1218:99:2;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;9216:141:0;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8762:100:3;;;:::i;:::-;;11408:182;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;835:94:2;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10497:147:0;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;935:277:2;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9452:149:0;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10363:708:3;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;8348:349;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;11693:435;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6180:314:0;6239:22;6410:20;6400:30;;6180:314;:::o;36052:197::-;36113:13;36226:6;36213:20;36204:29;;36052:197;;;:::o;36339:179::-;36469:1;36463:4;36456:15;36497:4;36491;36484:18;27253:160;27314:7;27338:11;27346:2;27338:7;:11::i;:::-;27333:44;;27358:19;;;;;;;;;;;;;;27333:44;27394:12;27403:2;27394:8;:12::i;:::-;27387:19;;27253:160;;;:::o;20880:1466::-;21010:22;21035:18;:16;:18::i;:::-;21010:43;;21082:1;21068:16;;:2;:16;;;21064:52;;21093:23;;;;;;;;;;;;;;21064:52;21127:13;21143:1;:16;;:49;21160:31;21165:1;:4;;21171:19;21187:2;21171:15;:19::i;:::-;21160:4;:31::i;:::-;21143:49;;;;;;;;;;;;;;;;;;;;;;;;;21127:65;;21215:5;21207:13;;:4;:13;;;21203:54;;21229:28;;;;;;;;;;;;;;21203:54;21285:4;21272:17;;:9;:17;;;21268:244;;21310:1;:19;;:25;21330:4;21310:25;;;;;;;;;;;;;;;:36;21336:9;21310:36;;;;;;;;;;;;;;;;;;;;;;;;;21305:197;;21383:1;:16;;:20;21400:2;21383:20;;;;;;;;;;;;;;;;;;;;;21370:33;;:9;:33;;;21366:122;;21434:35;;;;;;;;;;;;;;21366:122;21305:197;21268:244;21522:35;21560:18;21573:4;21560:12;:18::i;:::-;21522:56;;21588:33;21624:16;21637:2;21624:12;:16::i;:::-;21588:52;;3537:8;21651:15;:23;;;:39;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;3537:8;21725:13;:21;;;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21777:76;21782:1;:4;;21788:19;21804:2;21788:15;:19::i;:::-;21809:43;21834:13;21849:2;21809:24;:43::i;:::-;21777:4;:76::i;:::-;21874:1;:16;;:20;21891:2;21874:20;;;;;;;;;;;;21867:27;;;;;;;;;;;21909:17;21929:50;21934:1;:7;;:13;21942:4;21934:13;;;;;;;;;;;;;;;21951:15;:27;;;21949:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21929:50;;:4;:50::i;:::-;21909:70;;;;21993:67;21998:1;:7;;:13;22006:4;21998:13;;;;;;;;;;;;;;;22013:27;22018:1;:4;;22024:15;22036:2;22024:11;:15::i;:::-;22013:4;:27::i;:::-;21993:67;;22049:9;21993:4;:67::i;:::-;22075:9;22087:13;:25;;;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22075:39;;;;22128:63;22133:1;:4;;22139:22;22151:9;22139:11;:22::i;:::-;22163:27;22168:1;:4;;22174:15;22186:2;22174:11;:15::i;:::-;22163:4;:27::i;:::-;22128:4;:63::i;:::-;22205:32;22210:1;:7;;:11;22218:2;22210:11;;;;;;;;;;;;;;;22223:1;22233:2;22205:4;:32::i;:::-;22251:38;22256:1;:4;;22262:15;22274:2;22262:11;:15::i;:::-;22286:1;22251:4;:38::i;:::-;21701:599;;22330:2;22315:24;;22324:4;22315:24;;;3537:8;22315:24;;;;;;:::i;:::-;;;;;;;;21000:1346;;;;20880:1466;;;;:::o;28745:202::-;28932:8;28872:18;:16;:18::i;:::-;:36;;:47;28909:9;28872:47;;;;;;;;;;;;;;;:57;28920:8;28872:57;;;;;;;;;;;;;;;;:68;;;;;;;;;;;;;;;;;;28745:202;;;:::o;28114:509::-;28233:7;28256:22;28281:18;:16;:18::i;:::-;28256:43;;28310:13;28326:1;:16;;:49;28343:31;28348:1;:4;;28354:19;28370:2;28354:15;:19::i;:::-;28343:4;:31::i;:::-;28326:49;;;;;;;;;;;;;;;;;;;;;;;;;28310:65;;28403:5;28390:18;;:9;:18;;;28386:167;;28429:1;:19;;:26;28449:5;28429:26;;;;;;;;;;;;;;;:37;28456:9;28429:37;;;;;;;;;;;;;;;;;;;;;;;;;28424:119;;28493:35;;;;;;;;;;;;;;28424:119;28386:167;28586:7;28563:1;:16;;:20;28580:2;28563:20;;;;;;;;;;;;:30;;;;;;;;;;;;;;;;;;28611:5;28604:12;;;;28114:509;;;;;:::o;27711:189::-;27776:7;27800:11;27808:2;27800:7;:11::i;:::-;27795:44;;27820:19;;;;;;;;;;;;;;27795:44;27856:18;:16;:18::i;:::-;:33;;:37;27890:2;27856:37;;;;;;;;;;;;;;;;;;;;;27849:44;;27711:189;;;:::o;26656:151::-;26725:7;26751:18;:16;:18::i;:::-;:30;;:37;26782:5;26751:37;;;;;;;;;;;;;;;:49;;;;;;;;;;;;26744:56;;;;26656:151;;;:::o;26484:124::-;26542:7;26568:18;:16;:18::i;:::-;:33;;;;;;;;;;;;26561:40;;;;26484:124;:::o;739:90:2:-;785:13;817:5;810:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;739:90;:::o;9732:267:0:-;9806:4;9822:22;9847:18;:16;:18::i;:::-;9822:43;;9911:6;9876:1;:11;;:23;9888:10;9876:23;;;;;;;;;;;;;;;:32;9900:7;9876:32;;;;;;;;;;;;;;;:41;;;;9954:7;9933:37;;9942:10;9933:37;;;9963:6;9933:37;;;;;;:::i;:::-;;;;;;;;9988:4;9981:11;;;9732:267;;;;:::o;9026:124::-;9078:7;9112:18;:16;:18::i;:::-;:30;;;;;;;;;;;;9104:39;;9097:46;;9026:124;:::o;11323:497::-;11411:4;11427:22;11452:18;:16;:18::i;:::-;11427:43;;11481:15;11499:1;:11;;:17;11511:4;11499:17;;;;;;;;;;;;;;;:29;11517:10;11499:29;;;;;;;;;;;;;;;;11481:47;;11554:17;11543:7;:28;11539:215;;11600:7;11591:6;:16;11587:52;;;11616:23;;;;;;;;;;;;;;11587:52;11723:6;11713:7;:16;11681:1;:11;;:17;11693:4;11681:17;;;;;;;;;;;;;;;:29;11699:10;11681:29;;;;;;;;;;;;;;;:48;;;;11539:215;11764:27;11774:4;11780:2;11784:6;11764:9;:27::i;:::-;11809:4;11802:11;;;;11323:497;;;;;:::o;9021:617:3:-;9114:15;9150:28;:26;:28::i;:::-;9132:46;;:15;:46;9114:64;;9346:19;9340:4;9333:33;9396:8;9390:4;9383:22;9452:7;9445:4;9439;9429:21;9422:38;9599:8;9552:45;9549:1;9546;9541:67;9248:374;9021:617::o;23823:278:0:-;23883:4;23899:21;23923:18;:16;:18::i;:::-;:30;;:33;23954:1;23923:33;;;;;;;;;;;;;;;23899:57;;24014:1;3912:6;23970:1;:7;;;;;;;;;;;;:40;:45;;;23966:69;;24024:11;24033:1;24024:8;:11::i;:::-;24017:18;;;;;23966:69;24093:1;4046:6;24052:1;:7;;;;;;;;;;;;:37;:42;;;;24045:49;;;23823:278;;;;:::o;24208:98::-;24267:32;24279:10;24291:7;24267:11;:32::i;:::-;24208:98;:::o;8890:74::-;8931:5;8955:2;8948:9;;8890:74;:::o;1323:100:2:-;12517:13:3;:11;:13::i;:::-;1370:46:2::1;1405:10;1370:34;:46::i;:::-;1323:100::o:0;26318:117:0:-;26371:7;26397:18;:16;:18::i;:::-;:31;;;;;;;;;;;;26390:38;;26318:117;:::o;9720:456:3:-;9922:19;9916:4;9909:33;9968:8;9962:4;9955:22;10020:1;10013:4;10007;9997:21;9990:32;10151:8;10105:44;10102:1;10099;10094:66;9720:456::o;1218:99:2:-;12517:13:3;:11;:13::i;:::-;1302:8:2::1;;1291;:19;;;;;;;:::i;:::-;;1218:99:::0;;:::o;9216:141:0:-;9279:7;9305:18;:16;:18::i;:::-;:30;;:37;9336:5;9305:37;;;;;;;;;;;;;;;:45;;;;;;;;;;;;9298:52;;;;9216:141;;;:::o;8762:100:3:-;12517:13;:11;:13::i;:::-;8834:21:::1;8852:1;8834:9;:21::i;:::-;8762:100::o:0;11408:182::-;11454:14;11562:11;11556:18;11546:28;;11408:182;:::o;835:94:2:-;883:13;915:7;908:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;835:94;:::o;10497:147:0:-;10567:4;10583:33;10593:10;10605:2;10609:6;10583:9;:33::i;:::-;10633:4;10626:11;;10497:147;;;;:::o;935:277:2:-;1014:20;1076:1;1056:8;1050:22;;;;;:::i;:::-;;;:27;1046:160;;1143:8;1153:27;1172:7;1153:18;:27::i;:::-;1126:55;;;;;;;;;:::i;:::-;;;;;;;;;;;;;1093:102;;1046:160;935:277;;;:::o;9452:149:0:-;9524:7;9550:18;:16;:18::i;:::-;:28;;:35;9579:5;9550:35;;;;;;;;;;;;;;;:44;9586:7;9550:44;;;;;;;;;;;;;;;;9543:51;;9452:149;;;;:::o;10363:708:3:-;12517:13;:11;:13::i;:::-;10597:19:::1;10591:4;10584:33;10643:12;10637:4;10630:26;10705:4;10699;10689:21;10811:12;10805:19;10792:11;10789:36;10786:157;;;10857:10;10851:4;10844:24;10924:4;10918;10911:18;10786:157;11020:1;11006:12;10999:23;10515:517;11041:23;11051:12;11041:9;:23::i;:::-;10363:708:::0;:::o;8348:349::-;12517:13;:11;:13::i;:::-;8520:8:::1;8516:2;8512:17;8502:150;;8562:10;8556:4;8549:24;8633:4;8627;8620:18;8502:150;8671:19;8681:8;8671:9;:19::i;:::-;8348:349:::0;:::o;11693:435::-;11812:14;11963:19;11957:4;11950:33;12009:12;12003:4;11996:26;12106:4;12100;12090:21;12084:28;12074:38;;11693:435;;;:::o;27462:116:0:-;27522:4;27569:1;27545:26;;:12;27554:2;27545:8;:12::i;:::-;:26;;;;27538:33;;27462:116;;;:::o;26942:196::-;27003:7;27022:22;27047:18;:16;:18::i;:::-;27022:43;;27082:1;:16;;:49;27099:31;27104:1;:4;;27110:19;27126:2;27110:15;:19::i;:::-;27099:4;:31::i;:::-;27082:49;;;;;;;;;;;;;;;;;;;;;;;;;27075:56;;;26942:196;;;:::o;36798:97::-;36856:7;36887:1;36882;:6;;36875:13;;36798:97;;;:::o;37136:164::-;37210:13;37290:1;37284;37276:5;:9;37275:16;;37251:3;:7;;:19;37268:1;37259:5;:10;;37251:19;;;;;;;;;;;;:41;;37235:58;;37136:164;;;;:::o;24967:398::-;25026:21;25059:22;25084:18;:16;:18::i;:::-;25059:43;;25116:1;:13;;:16;25130:1;25116:16;;;;;;;;;;;;;;;25112:20;;25191:1;3912:6;25147:1;:7;;;;;;;;;;;;:40;:45;;;25143:216;;25208:11;3912:6;25208:44;;25270:11;25279:1;25270:8;:11::i;:::-;25266:53;;;4046:6;25283:36;;;;25266:53;25343:5;25333:1;:7;;;:15;;;;;;;;;;;;;;;;;;25194:165;25143:216;25049:316;24967:398;;;:::o;25526:457::-;25657:19;25692:22;25717:18;:16;:18::i;:::-;25692:43;;25760:13;:26;;;;;;;;;;;;25745:41;;25816:1;25800:12;:17;;;25796:181;;25850:1;:12;;;25848:14;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;25833:29;;25905:12;25876:13;:26;;;:41;;;;;;;;;;;;;;;;;;25964:2;25931:1;:16;;:30;25948:12;25931:30;;;;;;;;;;;;;;;;:35;;;;;;;;;;;;;;;;;;25796:181;25682:301;25526:457;;;;:::o;37365:531::-;37528:8;37522:4;37515:22;37570:5;37567:1;37563:13;37557:4;37550:27;37615:4;37609;37599:21;37677:1;37670:5;37666:13;37663:1;37659:21;37739:1;37733:8;37786:10;37870:5;37866:1;37863;37859:9;37855:21;37852:1;37848:29;37845:1;37841:37;37838:1;37834:45;37831:1;37824:56;37501:389;;;;37365:531;;;:::o;36938:133::-;36992:7;37053:1;37048;37043;:6;;37042:12;37035:19;;36938:133;;;:::o;17271:3197::-;17377:1;17363:16;;:2;:16;;;17359:52;;17388:23;;;;;;;;;;;;;;17359:52;17422:22;17447:18;:16;:18::i;:::-;17422:43;;17476:35;17514:18;17527:4;17514:12;:18::i;:::-;17476:56;;17542:33;17578:16;17591:2;17578:12;:16::i;:::-;17542:52;;17605:23;;:::i;:::-;17658:15;:27;;;;;;;;;;;;17638:47;;:1;:17;;:47;;;;;17713:13;:25;;;;;;;;;;;;17695:43;;:1;:15;;:43;;;;;17764:15;:23;;;;;;;;;;;;17748:39;;:1;:13;;:39;;;;;17811:1;:13;;;17802:6;:22;17798:56;;;17833:21;;;;;;;;;;;;;;17798:56;17906:6;17889:1;:13;;:23;;;;;;;;;;;17959:1;:13;;;17926:15;:23;;;:47;;;;;;;;;;;;;;;;;;18056:6;18032:13;:21;;;;;;;;;;;;:30;;;18018:1;:11;;:44;;;;17987:13;:21;;;:76;;;;;;;;;;;;;;;;;;18098:54;18112:1;:17;;;3537:8;18131:1;:13;;;:20;;;;;:::i;:::-;;;18098:13;:54::i;:::-;18078:1;:17;;:74;;;;;18224:1;4046:6;18171:13;:19;;;;;;;;;;;;:49;:54;;;18167:252;;18257:2;18249:10;;:4;:10;;;18245:71;;18299:1;:17;;;18279:1;:17;;;:37;18261:1;:15;;:55;;;;;18245:71;18354:50;3537:8;18368:1;:11;;;:18;;;;;:::i;:::-;;;18388:1;:15;;;18354:13;:50::i;:::-;18334:1;:17;;:70;;;;;18167:252;18433:29;18465:56;18503:1;:17;;;18483:1;:17;;;:37;18465:17;:56::i;:::-;18433:88;;18561:1;18540;:17;;;:22;18536:690;;18582:27;18612:1;:7;;:13;18620:4;18612:13;;;;;;;;;;;;;;;18582:43;;18643:17;18663:1;:17;;;18643:37;;18698:15;18728:1;:17;;;18716:9;:29;18698:47;;18790:1;:17;;;18763:1;:16;;;:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18863:7;18826:15;:27;;;:45;;;;;;;;;;;;;;;;;;18919:293;18944:10;18957:28;18962:9;18973:11;;;;;;;18957:4;:28::i;:::-;18944:41;;;;19007:43;19035:1;:4;;19041:2;19045:1;19048;19007:27;:43::i;:::-;19079:1;:16;;:20;19096:2;19079:20;;;;;;;;;;;;19072:27;;;;;;;;;;;19121:42;19139:10;19151:4;19157:2;19161:1;19121:17;:42::i;:::-;18922:260;19203:7;19190:9;:20;18919:293;;18564:662;;;18536:690;19265:1;19244;:17;;;:22;19240:1048;;19286:25;19314:1;:7;;:11;19322:2;19314:11;;;;;;;;;;;;;;;19286:39;;19343:15;19361:1;:15;;;19343:33;;19394:13;19420:1;:17;;;19410:7;:27;19394:43;;19455:14;19472:43;19497:13;19512:2;19472:24;:43::i;:::-;19455:60;;19533:16;3537:8;19552:1;:13;;;;;;;;;;;;:20;;;;;;;:::i;:::-;;;19533:39;;19590:10;19603:1;:13;;;;;;;;;;;;19590:26;;;;19661:1;:17;;;19634:1;:16;;;:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19732:5;19697:13;:25;;;:41;;;;;;;;;;;;;;;;;;19786:444;19811:121;19853:1;19818:31;19823:1;:4;;19829:19;19845:2;19829:15;:19::i;:::-;19818:4;:31::i;:::-;:36;;;19811:121;;19893:8;19886:4;;;;;;:15;19882:27;;;19908:1;19903:6;;19882:27;19811:121;;;19953:34;19958:7;19967;19983:2;19953:4;:34::i;:::-;20009:65;20037:1;:4;;20043:2;20047:7;20063:9;;;;;;20009:27;:65::i;:::-;20096:40;20114:10;20126:2;20130;20134:1;20096:17;:40::i;:::-;20169:8;20162:4;;;;;;:15;20158:27;;;20184:1;20179:6;;20158:27;20223:5;20212:7;:16;19786:444;;20270:2;20247:1;:13;;;:26;;;;;;;;;;;;;;;;;;19268:1020;;;;;;19240:1048;20332:1;20306:10;:15;;;:22;:27;20302:109;;20353:43;20369:10;20381:1;:14;;;;;;;;;;;;20353:15;:43::i;:::-;20302:109;17865:2556;20450:2;20435:26;;20444:4;20435:26;;;20454:6;20435:26;;;;;;:::i;:::-;;;;;;;;17349:3119;;;;17271:3197;;;:::o;7878:110:3:-;7947:6;7972:9;7965:16;;7878:110;:::o;35781:212:0:-;35832:11;35943:1;35931:14;35921:24;;35781:212;;;:::o;24518:283::-;24589:21;24613:15;24626:1;24613:12;:15::i;:::-;24589:39;;24690:5;24642:53;;24684:1;4046:6;24643:1;:7;;;;;;;;;;;;:37;:42;;;;24642:53;;;24638:122;;4046:6;24711:1;:7;;;:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24638:122;24785:1;24774:20;;;24788:5;24774:20;;;;;;:::i;:::-;;;;;;;;24579:222;24518:283;;:::o;7292:355:3:-;7504:11;7498:18;7488:8;7485:32;7475:156;;7550:10;7544:4;7537:24;7612:4;7606;7599:18;7475:156;7292:355::o;3515:406:5:-;3781:4;3769:10;3763:4;3751:10;3736:13;3732:2;3725:5;3720:66;3710:195;;3819:10;3813:4;3806:24;3886:4;3880;3873:18;3710:195;3515:406;:::o;6145:1089:3:-;6213:23;:21;:23::i;:::-;6209:1019;;;6343:11;6443:8;6439:2;6435:17;6431:2;6427:26;6415:38;;6597:8;6585:9;6579:16;6539:38;6536:1;6533;6528:78;6710:8;6703:16;6698:3;6694:26;6684:8;6681:40;6670:9;6663:59;6308:428;6209:1019;;;6857:11;6957:8;6953:2;6949:17;6945:2;6941:26;6929:38;;7111:8;7099:9;7093:16;7053:38;7050:1;7047;7042:78;7195:8;7184:9;7177:27;6822:396;6209:1019;6145:1089;:::o;1946:1641:4:-;2002:17;2447:4;2440;2434:11;2430:22;2423:29;;2546:4;2541:3;2537:14;2531:4;2524:28;2627:1;2622:3;2615:14;2728:3;2758:1;2754:6;2967:5;2949:402;2975:1;2949:402;;;3014:1;3009:3;3005:11;2998:18;;3200:2;3194:4;3190:13;3186:2;3182:22;3177:3;3169:36;3292:2;3286:4;3282:13;3274:21;;3322:4;2949:402;3312:25;2949:402;2953:21;3388:3;3383;3379:13;3501:4;3496:3;3492:14;3485:21;;3564:6;3559:3;3552:19;2083:1498;;;1946:1641;;;:::o;36562:199:0:-;36629:9;36742:1;36739;36735:9;36731:1;36728;36725:8;36721:24;36716:29;;36562:199;;;;:::o;33807:440::-;33867:20;;:::i;:::-;33994:4;33987;33981:11;33977:22;34069:1;34063:4;34056:15;34108:4;34102;34098:15;34158:1;34155;34151:9;34143:6;34139:22;34133:4;34126:36;34185:4;34182:1;34175:15;34224:6;34220:1;34214:4;34210:12;34203:28;33951:290;;33807:440;;;:::o;37966:691::-;38250:9;38238:10;38234:26;38221:10;38217:2;38213:19;38210:51;38287:8;38281:4;38274:22;38329:2;38326:1;38322:10;38316:4;38309:24;38371:4;38365;38355:21;38430:1;38426:2;38422:10;38419:1;38415:18;38492:1;38486:8;38539:18;38631:5;38627:1;38624;38620:9;38616:21;38613:1;38609:29;38606:1;38602:37;38599:1;38595:45;38592:1;38585:56;38183:468;;;;;37966:691;;;;:::o;34350:367::-;34578:1;34572:4;34568:12;34562:19;34640:7;34634:2;34631:1;34627:10;34623:1;34619:2;34615:10;34612:26;34609:39;34601:6;34594:55;34695:4;34687:6;34683:17;34679:1;34673:4;34669:12;34662:39;34534:177;34350:367;;;;:::o;34813:622::-;34978:1;34972:8;35012:4;35006;35002:15;35070:10;35067:1;35060:21;35144:4;35137;35134:1;35130:12;35123:26;35239:4;35233:11;35230:1;35226:19;35220:4;35216:30;35364:4;35361:1;35358;35351:4;35348:1;35344:12;35341:1;35333:6;35326:5;35321:48;35317:1;35313;35307:8;35304:15;35300:70;35290:129;;35400:4;35397:1;35390:15;35290:129;34946:483;;;34813:622;;:::o;4348:78:3:-;4412:10;4348:78;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;:::o;7:99:6:-;59:6;93:5;87:12;77:22;;7:99;;;:::o;112:169::-;196:11;230:6;225:3;218:19;270:4;265:3;261:14;246:29;;112:169;;;;:::o;287:246::-;368:1;378:113;392:6;389:1;386:13;378:113;;;477:1;472:3;468:11;462:18;458:1;453:3;449:11;442:39;414:2;411:1;407:10;402:15;;378:113;;;525:1;516:6;511:3;507:16;500:27;349:184;287:246;;;:::o;539:102::-;580:6;631:2;627:7;622:2;615:5;611:14;607:28;597:38;;539:102;;;:::o;647:377::-;735:3;763:39;796:5;763:39;:::i;:::-;818:71;882:6;877:3;818:71;:::i;:::-;811:78;;898:65;956:6;951:3;944:4;937:5;933:16;898:65;:::i;:::-;988:29;1010:6;988:29;:::i;:::-;983:3;979:39;972:46;;739:285;647:377;;;;:::o;1030:313::-;1143:4;1181:2;1170:9;1166:18;1158:26;;1230:9;1224:4;1220:20;1216:1;1205:9;1201:17;1194:47;1258:78;1331:4;1322:6;1258:78;:::i;:::-;1250:86;;1030:313;;;;:::o;1430:117::-;1539:1;1536;1529:12;1553:117;1662:1;1659;1652:12;1676:126;1713:7;1753:42;1746:5;1742:54;1731:65;;1676:126;;;:::o;1808:96::-;1845:7;1874:24;1892:5;1874:24;:::i;:::-;1863:35;;1808:96;;;:::o;1910:122::-;1983:24;2001:5;1983:24;:::i;:::-;1976:5;1973:35;1963:63;;2022:1;2019;2012:12;1963:63;1910:122;:::o;2038:139::-;2084:5;2122:6;2109:20;2100:29;;2138:33;2165:5;2138:33;:::i;:::-;2038:139;;;;:::o;2183:77::-;2220:7;2249:5;2238:16;;2183:77;;;:::o;2266:122::-;2339:24;2357:5;2339:24;:::i;:::-;2332:5;2329:35;2319:63;;2378:1;2375;2368:12;2319:63;2266:122;:::o;2394:139::-;2440:5;2478:6;2465:20;2456:29;;2494:33;2521:5;2494:33;:::i;:::-;2394:139;;;;:::o;2539:474::-;2607:6;2615;2664:2;2652:9;2643:7;2639:23;2635:32;2632:119;;;2670:79;;:::i;:::-;2632:119;2790:1;2815:53;2860:7;2851:6;2840:9;2836:22;2815:53;:::i;:::-;2805:63;;2761:117;2917:2;2943:53;2988:7;2979:6;2968:9;2964:22;2943:53;:::i;:::-;2933:63;;2888:118;2539:474;;;;;:::o;3019:90::-;3053:7;3096:5;3089:13;3082:21;3071:32;;3019:90;;;:::o;3115:109::-;3196:21;3211:5;3196:21;:::i;:::-;3191:3;3184:34;3115:109;;:::o;3230:210::-;3317:4;3355:2;3344:9;3340:18;3332:26;;3368:65;3430:1;3419:9;3415:17;3406:6;3368:65;:::i;:::-;3230:210;;;;:::o;3446:118::-;3533:24;3551:5;3533:24;:::i;:::-;3528:3;3521:37;3446:118;;:::o;3570:222::-;3663:4;3701:2;3690:9;3686:18;3678:26;;3714:71;3782:1;3771:9;3767:17;3758:6;3714:71;:::i;:::-;3570:222;;;;:::o;3798:619::-;3875:6;3883;3891;3940:2;3928:9;3919:7;3915:23;3911:32;3908:119;;;3946:79;;:::i;:::-;3908:119;4066:1;4091:53;4136:7;4127:6;4116:9;4112:22;4091:53;:::i;:::-;4081:63;;4037:117;4193:2;4219:53;4264:7;4255:6;4244:9;4240:22;4219:53;:::i;:::-;4209:63;;4164:118;4321:2;4347:53;4392:7;4383:6;4372:9;4368:22;4347:53;:::i;:::-;4337:63;;4292:118;3798:619;;;;;:::o;4423:329::-;4482:6;4531:2;4519:9;4510:7;4506:23;4502:32;4499:119;;;4537:79;;:::i;:::-;4499:119;4657:1;4682:53;4727:7;4718:6;4707:9;4703:22;4682:53;:::i;:::-;4672:63;;4628:117;4423:329;;;;:::o;4758:116::-;4828:21;4843:5;4828:21;:::i;:::-;4821:5;4818:32;4808:60;;4864:1;4861;4854:12;4808:60;4758:116;:::o;4880:133::-;4923:5;4961:6;4948:20;4939:29;;4977:30;5001:5;4977:30;:::i;:::-;4880:133;;;;:::o;5019:323::-;5075:6;5124:2;5112:9;5103:7;5099:23;5095:32;5092:119;;;5130:79;;:::i;:::-;5092:119;5250:1;5275:50;5317:7;5308:6;5297:9;5293:22;5275:50;:::i;:::-;5265:60;;5221:114;5019:323;;;;:::o;5348:86::-;5383:7;5423:4;5416:5;5412:16;5401:27;;5348:86;;;:::o;5440:112::-;5523:22;5539:5;5523:22;:::i;:::-;5518:3;5511:35;5440:112;;:::o;5558:214::-;5647:4;5685:2;5674:9;5670:18;5662:26;;5698:67;5762:1;5751:9;5747:17;5738:6;5698:67;:::i;:::-;5558:214;;;;:::o;5778:118::-;5865:24;5883:5;5865:24;:::i;:::-;5860:3;5853:37;5778:118;;:::o;5902:222::-;5995:4;6033:2;6022:9;6018:18;6010:26;;6046:71;6114:1;6103:9;6099:17;6090:6;6046:71;:::i;:::-;5902:222;;;;:::o;6130:117::-;6239:1;6236;6229:12;6253:117;6362:1;6359;6352:12;6376:117;6485:1;6482;6475:12;6513:553;6571:8;6581:6;6631:3;6624:4;6616:6;6612:17;6608:27;6598:122;;6639:79;;:::i;:::-;6598:122;6752:6;6739:20;6729:30;;6782:18;6774:6;6771:30;6768:117;;;6804:79;;:::i;:::-;6768:117;6918:4;6910:6;6906:17;6894:29;;6972:3;6964:4;6956:6;6952:17;6942:8;6938:32;6935:41;6932:128;;;6979:79;;:::i;:::-;6932:128;6513:553;;;;;:::o;7072:529::-;7143:6;7151;7200:2;7188:9;7179:7;7175:23;7171:32;7168:119;;;7206:79;;:::i;:::-;7168:119;7354:1;7343:9;7339:17;7326:31;7384:18;7376:6;7373:30;7370:117;;;7406:79;;:::i;:::-;7370:117;7519:65;7576:7;7567:6;7556:9;7552:22;7519:65;:::i;:::-;7501:83;;;;7297:297;7072:529;;;;;:::o;7607:329::-;7666:6;7715:2;7703:9;7694:7;7690:23;7686:32;7683:119;;;7721:79;;:::i;:::-;7683:119;7841:1;7866:53;7911:7;7902:6;7891:9;7887:22;7866:53;:::i;:::-;7856:63;;7812:117;7607:329;;;;:::o;7942:474::-;8010:6;8018;8067:2;8055:9;8046:7;8042:23;8038:32;8035:119;;;8073:79;;:::i;:::-;8035:119;8193:1;8218:53;8263:7;8254:6;8243:9;8239:22;8218:53;:::i;:::-;8208:63;;8164:117;8320:2;8346:53;8391:7;8382:6;8371:9;8367:22;8346:53;:::i;:::-;8336:63;;8291:118;7942:474;;;;;:::o;8422:109::-;8458:7;8498:26;8491:5;8487:38;8476:49;;8422:109;;;:::o;8537:180::-;8585:77;8582:1;8575:88;8682:4;8679:1;8672:15;8706:4;8703:1;8696:15;8723:216;8762:4;8782:19;8799:1;8782:19;:::i;:::-;8777:24;;8815:19;8832:1;8815:19;:::i;:::-;8810:24;;8858:1;8855;8851:9;8843:17;;8882:26;8876:4;8873:36;8870:62;;;8912:18;;:::i;:::-;8870:62;8723:216;;;;:::o;8945:180::-;8993:77;8990:1;8983:88;9090:4;9087:1;9080:15;9114:4;9111:1;9104:15;9131:320;9175:6;9212:1;9206:4;9202:12;9192:22;;9259:1;9253:4;9249:12;9280:18;9270:81;;9336:4;9328:6;9324:17;9314:27;;9270:81;9398:2;9390:6;9387:14;9367:18;9364:38;9361:84;;9417:18;;:::i;:::-;9361:84;9182:269;9131:320;;;:::o;9457:97::-;9516:6;9544:3;9534:13;;9457:97;;;;:::o;9560:180::-;9608:77;9605:1;9598:88;9705:4;9702:1;9695:15;9729:4;9726:1;9719:15;9746:141;9795:4;9818:3;9810:11;;9841:3;9838:1;9831:14;9875:4;9872:1;9862:18;9854:26;;9746:141;;;:::o;9893:93::-;9930:6;9977:2;9972;9965:5;9961:14;9957:23;9947:33;;9893:93;;;:::o;9992:107::-;10036:8;10086:5;10080:4;10076:16;10055:37;;9992:107;;;;:::o;10105:393::-;10174:6;10224:1;10212:10;10208:18;10247:97;10277:66;10266:9;10247:97;:::i;:::-;10365:39;10395:8;10384:9;10365:39;:::i;:::-;10353:51;;10437:4;10433:9;10426:5;10422:21;10413:30;;10486:4;10476:8;10472:19;10465:5;10462:30;10452:40;;10181:317;;10105:393;;;;;:::o;10504:60::-;10532:3;10553:5;10546:12;;10504:60;;;:::o;10570:142::-;10620:9;10653:53;10671:34;10680:24;10698:5;10680:24;:::i;:::-;10671:34;:::i;:::-;10653:53;:::i;:::-;10640:66;;10570:142;;;:::o;10718:75::-;10761:3;10782:5;10775:12;;10718:75;;;:::o;10799:269::-;10909:39;10940:7;10909:39;:::i;:::-;10970:91;11019:41;11043:16;11019:41;:::i;:::-;11011:6;11004:4;10998:11;10970:91;:::i;:::-;10964:4;10957:105;10875:193;10799:269;;;:::o;11074:73::-;11119:3;11074:73;:::o;11153:189::-;11230:32;;:::i;:::-;11271:65;11329:6;11321;11315:4;11271:65;:::i;:::-;11206:136;11153:189;;:::o;11348:186::-;11408:120;11425:3;11418:5;11415:14;11408:120;;;11479:39;11516:1;11509:5;11479:39;:::i;:::-;11452:1;11445:5;11441:13;11432:22;;11408:120;;;11348:186;;:::o;11540:543::-;11641:2;11636:3;11633:11;11630:446;;;11675:38;11707:5;11675:38;:::i;:::-;11759:29;11777:10;11759:29;:::i;:::-;11749:8;11745:44;11942:2;11930:10;11927:18;11924:49;;;11963:8;11948:23;;11924:49;11986:80;12042:22;12060:3;12042:22;:::i;:::-;12032:8;12028:37;12015:11;11986:80;:::i;:::-;11645:431;;11630:446;11540:543;;;:::o;12089:117::-;12143:8;12193:5;12187:4;12183:16;12162:37;;12089:117;;;;:::o;12212:169::-;12256:6;12289:51;12337:1;12333:6;12325:5;12322:1;12318:13;12289:51;:::i;:::-;12285:56;12370:4;12364;12360:15;12350:25;;12263:118;12212:169;;;;:::o;12386:295::-;12462:4;12608:29;12633:3;12627:4;12608:29;:::i;:::-;12600:37;;12670:3;12667:1;12663:11;12657:4;12654:21;12646:29;;12386:295;;;;:::o;12686:1403::-;12810:44;12850:3;12845;12810:44;:::i;:::-;12919:18;12911:6;12908:30;12905:56;;;12941:18;;:::i;:::-;12905:56;12985:38;13017:4;13011:11;12985:38;:::i;:::-;13070:67;13130:6;13122;13116:4;13070:67;:::i;:::-;13164:1;13193:2;13185:6;13182:14;13210:1;13205:632;;;;13881:1;13898:6;13895:84;;;13954:9;13949:3;13945:19;13932:33;13923:42;;13895:84;14005:67;14065:6;14058:5;14005:67;:::i;:::-;13999:4;13992:81;13854:229;13175:908;;13205:632;13257:4;13253:9;13245:6;13241:22;13291:37;13323:4;13291:37;:::i;:::-;13350:1;13364:215;13378:7;13375:1;13372:14;13364:215;;;13464:9;13459:3;13455:19;13442:33;13434:6;13427:49;13515:1;13507:6;13503:14;13493:24;;13562:2;13551:9;13547:18;13534:31;;13401:4;13398:1;13394:12;13389:17;;13364:215;;;13607:6;13598:7;13595:19;13592:186;;;13672:9;13667:3;13663:19;13650:33;13715:48;13757:4;13749:6;13745:17;13734:9;13715:48;:::i;:::-;13707:6;13700:64;13615:163;13592:186;13824:1;13820;13812:6;13808:14;13804:22;13798:4;13791:36;13212:625;;;13175:908;;12785:1304;;;12686:1403;;;:::o;14095:148::-;14197:11;14234:3;14219:18;;14095:148;;;;:::o;14273:874::-;14376:3;14413:5;14407:12;14442:36;14468:9;14442:36;:::i;:::-;14494:89;14576:6;14571:3;14494:89;:::i;:::-;14487:96;;14614:1;14603:9;14599:17;14630:1;14625:166;;;;14805:1;14800:341;;;;14592:549;;14625:166;14709:4;14705:9;14694;14690:25;14685:3;14678:38;14771:6;14764:14;14757:22;14749:6;14745:35;14740:3;14736:45;14729:52;;14625:166;;14800:341;14867:38;14899:5;14867:38;:::i;:::-;14927:1;14941:154;14955:6;14952:1;14949:13;14941:154;;;15029:7;15023:14;15019:1;15014:3;15010:11;15003:35;15079:1;15070:7;15066:15;15055:26;;14977:4;14974:1;14970:12;14965:17;;14941:154;;;15124:6;15119:3;15115:16;15108:23;;14807:334;;14592:549;;14380:767;;14273:874;;;;:::o;15153:390::-;15259:3;15287:39;15320:5;15287:39;:::i;:::-;15342:89;15424:6;15419:3;15342:89;:::i;:::-;15335:96;;15440:65;15498:6;15493:3;15486:4;15479:5;15475:16;15440:65;:::i;:::-;15530:6;15525:3;15521:16;15514:23;;15263:280;15153:390;;;;:::o;15549:429::-;15726:3;15748:92;15836:3;15827:6;15748:92;:::i;:::-;15741:99;;15857:95;15948:3;15939:6;15857:95;:::i;:::-;15850:102;;15969:3;15962:10;;15549:429;;;;;:::o;15984:93::-;16020:7;16060:10;16053:5;16049:22;16038:33;;15984:93;;;:::o;16083:175::-;16121:3;16144:23;16161:5;16144:23;:::i;:::-;16135:32;;16189:10;16182:5;16179:21;16176:47;;16203:18;;:::i;:::-;16176:47;16250:1;16243:5;16239:13;16232:20;;16083:175;;;:::o;16264:180::-;16312:77;16309:1;16302:88;16409:4;16406:1;16399:15;16433:4;16430:1;16423:15

ipfs://8a083749ffffb57f3052e9b106a32bcdece77fbaa56a8e029bd3221d149a8adc