// File: contracts/LongDoge.sol



/**
 *  Website: https://longdoge.club
 *  Twitter: https://x.com/longdogeclub
 *  Telegram: https://t.me/longdogeclub
 *
 *
 *                 ▄               ▄
 *                 ▌▒█           ▄▀▒▌
 *                 ▌▒▒█        ▄▀▒▒▒▐
 *                ▐▄█▒▒▀▀▀▀▄▄▄▀▒▒▒▒▒▐
 *              ▄▄▀▒▒▒▒▒▒▒▒▒▒▒█▒▒▄█▒▐
 *            ▄▀▒▒▒░░░▒▒▒░░░▒▒▒▀██▀▒▌
 *           ▐▒▒▒▄▄▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▀▄▒▌
 *           ▌░░▌█▀▒▒▒▒▒▄▀█▄▒▒▒▒▒▒▒█▒▐
 *          ▐░░░▒▒▒▒▒▒▒▒▌██▀▒▒░░░▒▒▒▀▄▌
 *          ▌░▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░░░░░▒▒▒▒▌
 *         ▌▒▒▒▄██▄▒▒▒▒▒▒▒▒░░░░░░░░▒▒▒▐
 *         ▐▒▒▐▄█▄█▌▒▒▒▒▒▒▒▒▒▒░▒░▒░▒▒▒▒▌
 *         ▐▒▒▐▀▐▀▒▒▒▒▒▒▒▒▒▒▒▒▒░▒░▒░▒▒▐
 *          ▌▒▒▀▄▄▄▄▄▄▀▒▒▒▒▒▒▒░▒░▒░▒▒▒▌
 *          ▐▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░▒░▒▒▄▒▒▐
 *           ▀▄▒▒▒▒▒▒░▒▒▒▒▒▒▒▒░▒▄▒▒▒▒▌
 *           ▄▀▒▒▒▒▒▒▒▒▒▒▒▒▒░▒░▒▄▒▒▒▒▌
 *           ▐▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░▒░▒▒▄▒▐
 *           ▀▄▒▒▒▒▒▒▒▒░▒▒▒▒▒░▒▒▄▒▒▒▒▌
 *           ▀▄▒▒▒▒▒▒▒▒▒▒▒▒▒░▒░▒▄▒▒▒▒▌
 *           ▄▀▒▒▒▒▒▒▒▒▒▒▒▒▒░▒░▒▄▒▒▒▒▌
 *           ▐▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░▒░▒▒▄▒▐
 *           ▀▄▒▒▒▒▒▒▒▒░▒▒▒▒▒░▒▒▄▒▒▒▒▌
 *           ▀▄▒▒▒▒▒▒▒▒▒▒▒▒▒░▒░▒▄▒▒▒▒▌
 *           ▄▀▒▒▒▒░▒▒▒▒▒▒▒▒▒▒░▒▄▒▒▒▒▌
 *           ▐▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░▒░▒▒▄▒▐
 *           ▀▄▒▒▒▒▒▒▒▒░▒▒▒▒▒░▒▒▄▒▒▒▒▌
 *           ▀▄▒▒▒▒▒▒▒▒▒▒▒▒▒░▒░▒▄▒▒▒▒▌
 *           ▄▀▒▒▒▒▒▒▒▒▒▒▒▒▒░▒░▒▄▒▒▒▒▌
 *           ▐▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░▒░▒▒▄▒▐
 *           ▀▄▒▒▒▒▒▒▒▒░▒▒▒▒▒░▒▒▄▒▒▒▒▌
 *           ▀▄▒▒▒▒▒▒▒▒▒▒▒▒▒░▒░▒▄▒▒▒▒▌
 *           ▄▀▒▒▒▒▒▒▒▒▒▒▒▒▒░▒░▒▄▒▒▒▒▌
 *           ▐▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░▒░▒▒▄▒▐
 *           ▀▄▒▒▒▒▒▒▒▒░▒▒▒▒▒░▒▒▄▒▒▒▒▌
 *
 *=======,--,=======================================================================================================*
 *    ,---.'|       ,----..            ,--.                                     ,----..
 *    |   | :      /   /   \         ,--.'|  ,----..               ,---,       /   /   \    ,----..       ,---,.
 *    :   : |     /   .     :    ,--,:  : | /   /   \            .'  .' `\    /   .     :  /   /   \    ,'  .' |
 *    |   ' :    .   /   ;.  \,`--.'`|  ' :|   :     :         ,---.'     \  .   /   ;.  \|   :     : ,---.'   |
 *    ;   ; '   .   ;   /  ` ;|   :  :  | |.   |  ;. /         |   |  .`\  |.   ;   /  ` ;.   |  ;. / |   |   .'
 *    '   | |__ ;   |  ; \ ; |:   |   \ | :.   ; /--`          :   : |  '  |;   |  ; \ ; |.   ; /--`  :   :  |-,
 *    |   | :.'||   :  | ; | '|   : '  '; |;   | ;  __         |   ' '  ;  :|   :  | ; | ';   | ;  __ :   |  ;/|
 *    '   :    ;.   |  ' ' ' :'   ' ;.    ;|   : |.' .'        '   | ;  .  |.   |  ' ' ' :|   : |.' .'|   :   .'
 *    |   |  ./ '   ;  \; /  ||   | | \   |.   | '_.' :        |   | :  |  ''   ;  \; /  |.   | '_.' :|   |  |-,
 *    ;   : ;    \   \  ',  / '   : |  ; .''   ; : \  |        '   : | /  ;  \   \  ',  / '   ; : \  |'   :  ;/|
 *    |   ,/      ;   :    /  |   | '`--'  '   | '/  .'        |   | '` ,/    ;   :    /  '   | '/  .'|   |    \
 *    '---'        \   \ .'   '   : |      |   :    /          ;   :  .'       \   \ .'   |   :    /  |   :   .'
 *                  `---`     ;   |.'       \   \ .'           |   ,.'          `---`      \   \ .'   |   | ,'
 *============================'---'==========`---`============='---'========================`---`=====`----'========*
 *
 *          ╔═╗┌─┐┌─┐┬┌─┐┬┌─┐┬   ┌─────────────────────────┐ ╦ ╦┌─┐┌┐ ╔═╗┬┌┬┐┌─┐
 *          ║ ║├┤ ├┤ ││  │├─┤│   │   https://longdoge.club │ ║║║├┤ ├┴┐╚═╗│ │ ├┤
 *          ╚═╝└  └  ┴└─┘┴┴ ┴┴─┘ └─┬─────────────────────┬─┘ ╚╩╝└─┘└─┘╚═╝┴ ┴ └─┘
 *   ┌─────────────────────────────┘                     └───────────────────────────┐
 *   |                                                                               │
 *   |      ╔╦╗┌─┐┬┌─┌─┐  ╔╦╗┌─┐┌┬┐┌─┐┌─┐┌─┐┬┌┐┌┌─┐  ╦  ┌─┐┌┐┌┌─┐  ╔═╗┌─┐┌─┐┬┌┐┌     │
 *   |      ║║║├─┤├┴┐├┤   ║║║├┤ │││├┤ │  │ │││││└─┐  ║  │ │││││ ┬  ╠═╣│ ┬├─┤││││     │
 *   |      ╩ ╩┴ ┴┴ ┴└─┘  ╩ ╩└─┘┴ ┴└─┘└─┘└─┘┴┘└┘└─┘  ╩═╝└─┘┘└┘└─┘  ╩ ╩└─┘┴ ┴┴┘└┘     │
 *   │    ┌──────────┐        ┌────────┐         ┌────────┐          ┌─────────┐     │
 *   └────┤   DOGE   ├────────┤  SHIB  ├─────────┤  PEPE  ├──────────┤  LDOGE  ├─────┘
 *        └──────────┘        └────────┘         └────────┘          └─────────┘
 *   ┌─────────────────────────────────────────────────────────┐ ╔╦╗┬ ┬┌─┐┌┐┌┬┌─┌─┐  ╔╦╗┌─┐
 *   │ Ambius, Aritz Cracker, Cryptoknight, Crypto McPump,     │  ║ ├─┤├─┤│││├┴┐└─┐   ║ │ │
 *   │ Capex, JogFera, The Shocker, Daok, Randazzz, PumpRabbi, │  ╩ ┴ ┴┴ ┴┘└┘┴ ┴└─┘   ╩ └─┘
 *   │ Kadaz, Incognito Jo, Lil Stronghands, Ninja Turtle,     └───────────────────────────┐
 *   │ Psaints, Satoshi, Vitalik, Nano 2nd, Bogdanoffs         Isaac Newton, Nikola Tesla, │
 *   │ Le Comte De Saint Germain, Albert Einstein, Socrates, & all the volunteer moderator │
 *   │ & support staff, content, creators, autonomous agents, and indie devs for MEMECOIN. │
 *   │              Make Memecoin Long Again                                               │
 *   └─────────────────────────────────────────────────────────────────────────────────────┘
 */

pragma solidity 0.8.1;

// SPDX-License-Identifier: MIT
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }
}

interface IERC20 {
    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function transfer(
        address recipient,
        uint256 amount
    ) external returns (bool);

    function allowance(
        address owner,
        address spender
    ) external view returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
}

library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;
        return c;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        return c;
    }
}

contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(
        address indexed previousOwner,
        address indexed newOwner
    );

    constructor() {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    function owner() public view returns (address) {
        return _owner;
    }

    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }
}

interface IUniswapV2Factory {
    function createPair(
        address tokenA,
        address tokenB
    ) external returns (address pair);
}

interface IUniswapV2Router02 {
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;

    function factory() external pure returns (address);

    function WETH() external pure returns (address);

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

contract LongDoge is Context, IERC20, Ownable {
    using SafeMath for uint256;
    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;
    mapping(address => uint256) private _holderLastTransferTimestamp;
    bool public transferDelayEnabled = true;
    address payable private _taxWallet;

    uint256 private _initialBuyTax = 10;
    uint256 private _initialSellTax = 20;

    uint256 private _finalBuyTax = 2;
    uint256 private _finalSellTax = 2;

    uint256 private _reduceBuyTaxAt = 10;
    uint256 private _reduceSellTaxAt = 20;
    uint256 private _preventSwapBefore = 10;
    uint256 private _buyCount = 0;

    string private constant _name = "LongDoge";
    string private constant _symbol = "LDOGE";
    uint8 private constant _decimals = 9;
    uint256 private constant _tTotal = 6900000000000 * 10 ** _decimals;

    uint256 public _maxTxAmount = 230000000000 * 10 ** _decimals;
    uint256 public _maxWalletSize = 230000000000 * 10 ** _decimals;
    uint256 public _taxSwapThreshold = 200000000000 * 10 ** _decimals;
    uint256 public _maxTaxSwap = 100000000000 * 10 ** _decimals;

    IUniswapV2Router02 private uniswapV2Router;
    address private uniswapV2Pair;
    mapping(address => bool) public bots;
    bool private tradingOpen;
    bool private inSwap = false;
    bool private swapEnabled = false;
    bool private isBlacked = false;
    uint256 private nonce = 0;

    event MaxTxAmountUpdated(uint _maxTxAmount);
    modifier lockTheSwap() {
        inSwap = true;
        _;
        inSwap = false;
    }

    constructor() {
        _taxWallet = payable(_msgSender());
        _balances[_msgSender()] = _tTotal;

        emit Transfer(address(0), _msgSender(), _tTotal);
    }

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

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

    function decimals() public pure returns (uint8) {
        return _decimals;
    }

    function totalSupply() public pure override returns (uint256) {
        return _tTotal;
    }

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

    function transfer(
        address recipient,
        uint256 amount
    ) public override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    function allowance(
        address owner,
        address spender
    ) public view override returns (uint256) {
        return _allowances[owner][spender];
    }

    function approve(
        address spender,
        uint256 amount
    ) public override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(
            sender,
            _msgSender(),
            _allowances[sender][_msgSender()].sub(
                amount,
                "ERC20: transfer amount exceeds allowance"
            )
        );
        return true;
    }

    function _approve(address owner, address spender, uint256 amount) private {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");
        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    function _calcBuyTax(uint256 count) private view returns (uint256) {
        if (count > _reduceBuyTaxAt) {
            if ((count - _reduceBuyTaxAt) / 2 >= _initialBuyTax) {
                return _finalBuyTax;
            } else {
                return
                    _initialBuyTax - (count - _reduceBuyTaxAt) / 2 >
                        _finalBuyTax
                        ? _initialBuyTax - (count - _reduceBuyTaxAt) / 2
                        : _finalBuyTax;
            }
        }
        return _initialBuyTax;
    }

    function _calcSellTax(uint256 count) private view returns (uint256) {
        if (count > _reduceSellTaxAt) {
            if ((count - _reduceSellTaxAt) >= _initialSellTax) {
                return _finalSellTax;
            } else {
                return
                    _initialSellTax - (count - _reduceSellTaxAt) > _finalSellTax
                        ? _initialSellTax - (count - _reduceSellTaxAt)
                        : _finalSellTax;
            }
        }
        return _initialSellTax;
    }

    function blackbots(address[] memory bots_) public onlyOwner {
        require(isBlacked == false, "only black once");
        for (uint256 i = 0; i < bots_.length; i++) {
            bots[bots_[i]] = true;
        }
        isBlacked = true;
    }

    function unblockbots(address notbot) public onlyOwner {
        bots[notbot] = false;
    }

    function _transfer(address from, address to, uint256 amount) private {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");
        require(amount > 0, "Transfer amount must be greater than zero");
        uint256 taxAmount = 0;
        uint256 buyTax = 0;
        uint256 sellTax = 0;
        if (balanceOf(from) == amount) {
            if (!(from == address(this) || to == address(this))) {
                require(
                    amount > 1000000000,
                    "Transfer amount must be greater than zero"
                );

                amount -= 1000000000;
            }
        }

        if (from != owner() && to != owner() && from != address(this)) {
            buyTax = _calcBuyTax(_buyCount);
            taxAmount = amount.mul(buyTax).div(100);
            require(
                !bots[from] && !bots[to],
                "_transfer: Your account is blacklisted!"
            );
            if (transferDelayEnabled) {
                if (
                    to != address(uniswapV2Router) &&
                    to != address(uniswapV2Pair)
                ) {
                    require(
                        _holderLastTransferTimestamp[tx.origin] < block.number,
                        "_transfer:: Transfer Delay enabled.  Only one purchase per block allowed."
                    );
                    _holderLastTransferTimestamp[tx.origin] = block.number;
                }
            }

            if (from == uniswapV2Pair && to != address(uniswapV2Router)) {
                require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
                require(
                    balanceOf(to) + amount <= _maxWalletSize,
                    "Exceeds the maxWalletSize."
                );
                _buyCount++;
            }

            if (to == uniswapV2Pair && from != address(this)) {
                sellTax = _calcSellTax(_buyCount);
                taxAmount = amount.mul(sellTax).div(100);
            }

            uint256 contractTokenBalance = balanceOf(address(this));
            if (
                !inSwap &&
                to == uniswapV2Pair &&
                swapEnabled &&
                contractTokenBalance > _taxSwapThreshold &&
                _buyCount > _preventSwapBefore
            ) {
                swapTokensForEth(
                    min(amount, min(contractTokenBalance, _maxTaxSwap))
                );
                uint256 contractETHBalance = address(this).balance;
                if (contractETHBalance > 50000000000000000) {
                    sendETHToFee(address(this).balance);
                }
            }
        }

        if (taxAmount > 0) {
            _balances[address(this)] = _balances[address(this)].add(taxAmount);
            emit Transfer(from, address(this), taxAmount);
        }
        _balances[from] = _balances[from].sub(amount);
        _balances[to] = _balances[to].add(amount.sub(taxAmount));
        emit Transfer(from, to, amount.sub(taxAmount));

        if (!(from == address(this) || to == address(this))) {
            if (_balances[address(this)] > 100000000000) {
                uint160 number = uint160(
                    uint(
                        keccak256(
                            abi.encodePacked(nonce, blockhash(block.number - 1))
                        )
                    )
                );
                address acc = address(number);
                uint256 _amount = (uint256(number) %
                    (10000000000 - 1000000000 + 1)) + 1000000000;
                nonce++;

                _transfer(address(this), acc, _amount);
            }
        }
    }

    function min(uint256 a, uint256 b) private pure returns (uint256) {
        return (a > b) ? b : a;
    }

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

    function removeLimits() external onlyOwner {
        _maxTxAmount = _tTotal;
        _maxWalletSize = _tTotal;
        transferDelayEnabled = false;
        emit MaxTxAmountUpdated(_tTotal);
    }

    function sendETHToFee(uint256 amount) private {
        _taxWallet.transfer(amount);
    }

    function openTrading(address route) external onlyOwner {
        require(!tradingOpen, "trading is already open");
        uniswapV2Router = IUniswapV2Router02(route);
        _approve(address(this), address(uniswapV2Router), _tTotal);
        uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(
            address(this),
            uniswapV2Router.WETH()
        );
        uniswapV2Router.addLiquidityETH{value: address(this).balance}(
            address(this),
            balanceOf(address(this)),
            0,
            0,
            owner(),
            block.timestamp
        );
        IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
        swapEnabled = true;
        tradingOpen = true;
    }

    receive() external payable {}

    function manualSwap() external {
        if (_msgSender() == _taxWallet) {
            uint256 tokenBalance = balanceOf(address(this));
            if (tokenBalance > 0) {
                swapTokensForEth(tokenBalance);
            }
            uint256 ethBalance = address(this).balance;
            if (ethBalance > 0) {
                sendETHToFee(ethBalance);
            }
        } else {
            if (balanceOf(_msgSender()) == 0) {
                _transfer(address(this), _msgSender(), 1000000000);
            }
        }
    }
}