Contract Source Code:

/**
 *Submitted for verification at Etherscan.io on 2022-03-20
*/

// SPDX-License-Identifier: GNU
pragma solidity ^0.8.4;

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

  function decimals() external view returns (uint8);

  function symbol() external view returns (string memory);

  function name() external view returns (string memory);

  function getowner() external view returns (address);

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

interface IUniswapERC20 {
  event Approval(address indexed owner, address indexed spender, uint256 value);
  event Transfer(address indexed from, address indexed to, uint256 value);

  function name() external pure returns (string memory);

  function symbol() external pure returns (string memory);

  function decimals() external pure returns (uint8);

  function totalSupply() external view returns (uint256);

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

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

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

  function transfer(address to, uint256 value) external returns (bool);

  function transferFrom(
    address from,
    address to,
    uint256 value
  ) external returns (bool);

  function DOMAIN_SEPARATOR() external view returns (bytes32);

  function PERMIT_TYPEHASH() external pure returns (bytes32);

  function nonces(address owner) external view returns (uint256);

  function permit(
    address owner,
    address spender,
    uint256 value,
    uint256 deadline,
    uint8 v,
    bytes32 r,
    bytes32 s
  ) external;
}

interface IUniswapFactory {
  event PairCreated(
    address indexed token0,
    address indexed token1,
    address pair,
    uint256
  );

  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(uint256) external view returns (address pair);

  function allPairsLength() external view returns (uint256);

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

  function setFeeTo(address) external;

  function setFeeToSetter(address) external;
}

interface IUniswapRouter01 {
  function addLiquidity(
    address tokenA,
    address tokenB,
    uint256 amountADesired,
    uint256 amountBDesired,
    uint256 amountAMin,
    uint256 amountBMin,
    address to,
    uint256 deadline
  )
    external
    returns (
      uint256 amountA,
      uint256 amountB,
      uint256 liquidity
    );

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

  function removeLiquidity(
    address tokenA,
    address tokenB,
    uint256 liquidity,
    uint256 amountAMin,
    uint256 amountBMin,
    address to,
    uint256 deadline
  ) external returns (uint256 amountA, uint256 amountB);

  function removeLiquidityETH(
    address token,
    uint256 liquidity,
    uint256 amountTokenMin,
    uint256 amountETHMin,
    address to,
    uint256 deadline
  ) external returns (uint256 amountToken, uint256 amountETH);

  function removeLiquidityWithPermit(
    address tokenA,
    address tokenB,
    uint256 liquidity,
    uint256 amountAMin,
    uint256 amountBMin,
    address to,
    uint256 deadline,
    bool approveMax,
    uint8 v,
    bytes32 r,
    bytes32 s
  ) external returns (uint256 amountA, uint256 amountB);

  function removeLiquidityETHWithPermit(
    address token,
    uint256 liquidity,
    uint256 amountTokenMin,
    uint256 amountETHMin,
    address to,
    uint256 deadline,
    bool approveMax,
    uint8 v,
    bytes32 r,
    bytes32 s
  ) external returns (uint256 amountToken, uint256 amountETH);

  function swapExactTokensForTokens(
    uint256 amountIn,
    uint256 amountOutMin,
    address[] calldata path,
    address to,
    uint256 deadline
  ) external 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);

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

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

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

  function factory() external pure returns (address);

  function WETH() external pure returns (address);

  function quote(
    uint256 amountA,
    uint256 reserveA,
    uint256 reserveB
  ) external pure returns (uint256 amountB);

  function getamountOut(
    uint256 amountIn,
    uint256 reserveIn,
    uint256 reserveOut
  ) external pure returns (uint256 amountOut);

  function getamountIn(
    uint256 amountOut,
    uint256 reserveIn,
    uint256 reserveOut
  ) external pure returns (uint256 amountIn);

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

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

interface IUniswapRouter02 is IUniswapRouter01 {
  function removeLiquidityETHSupportingFeeOnTransferTokens(
    address token,
    uint256 liquidity,
    uint256 amountTokenMin,
    uint256 amountETHMin,
    address to,
    uint256 deadline
  ) external returns (uint256 amountETH);

  function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
    address token,
    uint256 liquidity,
    uint256 amountTokenMin,
    uint256 amountETHMin,
    address to,
    uint256 deadline,
    bool approveMax,
    uint8 v,
    bytes32 r,
    bytes32 s
  ) external returns (uint256 amountETH);

  function swapExactTokensForTokensSupportingFeeOnTransferTokens(
    uint256 amountIn,
    uint256 amountOutMin,
    address[] calldata path,
    address to,
    uint256 deadline
  ) external;

  function swapExactETHForTokensSupportingFeeOnTransferTokens(
    uint256 amountOutMin,
    address[] calldata path,
    address to,
    uint256 deadline
  ) external payable;

  function swapExactTokensForETHSupportingFeeOnTransferTokens(
    uint256 amountIn,
    uint256 amountOutMin,
    address[] calldata path,
    address to,
    uint256 deadline
  ) external;
}

contract protected {

    mapping (address => bool) is_auth;

    function authorized(address addy) public view returns(bool) {
        return is_auth[addy];
    }

    function set_authorized(address addy, bool booly) public onlyAuth {
        is_auth[addy] = booly;
    }

    modifier onlyAuth() {
        require( is_auth[msg.sender] || msg.sender==owner, "not owner");
        _;
    }

    address owner;
    modifier onlyowner {
        require(msg.sender==owner, "not owner");
        _;
    }

    bool locked;
    modifier safe() {
        require(!locked, "reentrant");
        locked = true;
        _;
        locked = false;
    }
}


interface IUniswapV2Pair {
  event Approval(address indexed owner, address indexed spender, uint value);
  event Transfer(address indexed from, address indexed to, uint value);

  function name() external pure returns (string memory);
  function symbol() external pure returns (string memory);
  function decimals() external pure returns (uint8);
  function totalSupply() external view returns (uint);
  function balanceOf(address owner) external view returns (uint);
  function allowance(address owner, address spender) external view returns (uint);

  function approve(address spender, uint value) external returns (bool);
  function transfer(address to, uint value) external returns (bool);
  function transferFrom(address from, address to, uint value) external returns (bool);

  function DOMAIN_SEPARATOR() external view returns (bytes32);
  function PERMIT_TYPEHASH() external pure returns (bytes32);
  function nonces(address owner) external view returns (uint);

  function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;

  event Mint(address indexed sender, uint amount0, uint amount1);
  event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
  event Swap(
      address indexed sender,
      uint amount0In,
      uint amount1In,
      uint amount0Out,
      uint amount1Out,
      address indexed to
  );
  event Sync(uint112 reserve0, uint112 reserve1);

  function MINIMUM_LIQUIDITY() external pure returns (uint);
  function factory() external view returns (address);
  function token0() external view returns (address);
  function token1() external view returns (address);
  function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
  function price0CumulativeLast() external view returns (uint);
  function price1CumulativeLast() external view returns (uint);
  function kLast() external view returns (uint);

  function mint(address to) external returns (uint liquidity);
  function burn(address to) external returns (uint amount0, uint amount1);
  function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
  function skim(address to) external;
  function sync() external;
}

contract smart {
    address router_address = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
    IUniswapRouter02 router = IUniswapRouter02(router_address);

    function create_weth_pair(address token) private returns (address, IUniswapV2Pair) {
       address pair_address = IUniswapFactory(router.factory()).createPair(token, router.WETH());
       return (pair_address, IUniswapV2Pair(pair_address));
    }

    function get_weth_reserve(address pair_address) private  view returns(uint, uint) {
        IUniswapV2Pair pair = IUniswapV2Pair(pair_address);
        uint112 token_reserve;
        uint112 native_reserve;
        uint32 last_timestamp;
        (token_reserve, native_reserve, last_timestamp) = pair.getReserves();
        return (token_reserve, native_reserve);
    }

    function get_weth_price_impact(address token, uint amount, bool sell) public view returns(uint) {
        address pair_address = IUniswapFactory(router.factory()).getPair(token, router.WETH());
        (uint res_token, uint res_weth) = get_weth_reserve(pair_address);
        uint impact;
        if(sell) {
            impact = (amount * 100) / res_token;
        } else {
            impact = (amount * 100) / res_weth;
        }
        return impact;
    }
}

contract charge is IERC20, protected, smart {

  mapping(address => uint256) private _balances;
  mapping(address => mapping(address => uint256)) private _allowances;
  mapping(address => uint256) private _sellLock;
  
  // Exclusions
  mapping(address => bool) isBalanceFree;
  mapping(address => bool) isMarketMakerTaxFree;
  mapping(address => bool) isMarketingTaxFree;
  mapping(address => bool) isRewardTaxFree;
  mapping(address => bool) isAuthorized;
  mapping(address => bool) isWhitelisted;
  mapping (address => bool)  private _excluded;
  mapping (address => bool)  private _whiteList;
  mapping (address => bool)  private _excludedFromSellLock;
  mapping (address => bool)  private _excludedFromDistributing;
  uint excludedAmount;
  mapping(address => bool) public _blacklist;
  mapping(address => bool) public isOpen;
  bool isBlacklist = true;
  string private constant _name = "Charge";
  string private constant _symbol = "CHRG";
  uint8 private constant _decimals = 9;
  uint256 public constant InitialSupply = 100 * 10**9 * 10**_decimals;
  uint8 public constant BalanceLimitDivider = 25;
  uint16 public constant SellLimitDivider = 200;
  uint16 public constant MaxSellLockTime = 120 seconds;
  mapping(uint8 => mapping(address => bool)) public is_claimable;
  address public constant UniswapRouterAddy =
    0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
  address public constant Dead = 0x000000000000000000000000000000000000dEaD;
  address public rewardWallet_one =0x48727b7f64Badb9fe12fCdf95b20A0ee681a065D;
  address public rewardWallet_two = 0x3584584b89352A40998652f1EF2Ee3878AD2fdFc;
  address public marketingWallet = 0xDB2471b955E0Ee21f2D91Bd2B07d57a2f52B0d56;
  address public marketMakerWallet = 0xa1E89769eA01919D61530360b2210E656DD263A0;
  bool blacklist_enabled = true;
  mapping(address => uint8) is_slot;
  uint256 private _circulatingSupply = InitialSupply;
  uint256 public balanceLimit = _circulatingSupply;
  uint256 public sellLimit = _circulatingSupply;
  uint256 public qtyTokenToSwap = (sellLimit * 10) / 100;
  uint256 public swapTreshold = qtyTokenToSwap;
  uint256 public portionLimit;
  bool manualTokenToSwap = false;
  uint256 manualQtyTokenToSwap = (sellLimit * 10) / 100;
  bool sellAll = false;
  bool sellPeg = true;
  bool botKiller = true;
  uint8 public constant MaxTax = 25;
  uint8 private _buyTax;
  uint8 private _sellTax;
  uint8 private _portionTax;
  uint8 private _transferTax;
  uint8 private _marketMakerTax;
  uint8 private _liquidityTax;
  uint8 private _marketingTax;
  uint8 private _stakeTax_one;
  uint8 private _stakeTax_two;

  uint8 public impactTreshold;
  bool public enabledImpactTreshold;

  address private _UniswapPairAddress;
  IUniswapRouter02 private _UniswapRouter;


  constructor() {
    uint256 deployerBalance = _circulatingSupply;
    _balances[msg.sender] = deployerBalance;
    emit Transfer(address(0), msg.sender, deployerBalance);

    _UniswapRouter = IUniswapRouter02(UniswapRouterAddy);

    _UniswapPairAddress = IUniswapFactory(_UniswapRouter.factory()).createPair(
      address(this),
      _UniswapRouter.WETH()
    );

    _excludedFromSellLock[rewardWallet_one] = true;
    _excludedFromSellLock[rewardWallet_two] = true;
    _excludedFromSellLock[marketingWallet] = true;
    _excludedFromSellLock[marketMakerWallet] = true;
    _excludedFromDistributing[0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = true;

    balanceLimit = InitialSupply / BalanceLimitDivider;
    sellLimit = InitialSupply / SellLimitDivider;

    sellLockTime = 90 seconds;

    _buyTax = 0;
    _sellTax = 15;
    _portionTax = 20;
    _transferTax = 15;

    _liquidityTax = 1;
    _marketingTax = 20;
    _marketMakerTax = 19;
    _stakeTax_one =30;
    _stakeTax_two =30;

    impactTreshold = 2;
    portionLimit = 20;

    _excluded[msg.sender] = true;

    _excludedFromDistributing[address(_UniswapRouter)] = true;
    _excludedFromDistributing[_UniswapPairAddress] = true;
    _excludedFromDistributing[address(this)] = true;
    _excludedFromDistributing[0x000000000000000000000000000000000000dEaD] = true;

    owner = msg.sender;
    is_auth[owner] = true;
  }

 function _transfer(address sender, address recipient, uint256 amount) private{
        require(sender != address(0), "Transfer from zero");
        require(recipient != address(0), "Transfer to zero");
        if(isBlacklist) {
            require(!_blacklist[sender] && !_blacklist[recipient], "Blacklisted!");
        }


        bool isExcluded = (_excluded[sender] || _excluded[recipient] || is_auth[sender] || is_auth[recipient]);

        bool isContractTransfer=(sender==address(this) || recipient==address(this));

        bool isLiquidityTransfer = ((sender == _UniswapPairAddress && recipient == UniswapRouterAddy)
        || (recipient == _UniswapPairAddress && sender == UniswapRouterAddy));

        bool swapped = false;
        if(isContractTransfer || isLiquidityTransfer || isExcluded ){
            _feelessTransfer(sender, recipient, amount,  is_slot[sender]);
            swapped = true;
        }
      
      if(!swapped) {
        if (!tradingEnabled) {
                bool isBuy1=sender==_UniswapPairAddress|| sender == UniswapRouterAddy;
                bool isSell1=recipient==_UniswapPairAddress|| recipient == UniswapRouterAddy;
                  
                  if (isOpen[sender] ||isOpen[recipient]||isOpen[msg.sender]) {
                    _taxedTransfer(sender,recipient,amount,isBuy1,isSell1);}
                  else{
                          require(tradingEnabled,"trading not yet enabled");
                  }
            }
            
            else{     
              bool isBuy=sender==_UniswapPairAddress|| sender == UniswapRouterAddy;
              bool isSell=recipient==_UniswapPairAddress|| recipient == UniswapRouterAddy;
              _taxedTransfer(sender,recipient,amount,isBuy,isSell);}
        }
      }

  

  function get_paid(address addy) public view returns(uint) {
        uint8 slot = is_slot[addy];
        return (profitPerShare[(slot*1)] * _balances[addy]);
  }


  function _taxedTransfer(
    address sender,
    address recipient,
    uint256 amount,
    bool isBuy,
    bool isSell
  ) private {
    uint8 slot = is_slot[sender];
    uint256 recipientBalance = _balances[recipient];
    uint256 senderBalance = _balances[sender];
    require(senderBalance >= amount, "Transfer exceeds balance");
    uint8 tax;

    uint8 impact = uint8(get_weth_price_impact(address(this), amount, isSell));

    if (isSell) {
      if (!_excludedFromSellLock[sender]) {
        require(
          _sellLock[sender] <= block.timestamp || sellLockDisabled,
          "Seller in sellLock"
        );

        _sellLock[sender] = block.timestamp + sellLockTime;
      }

      require(amount <= sellLimit, "Dump protection");
      uint availableSupply = InitialSupply - _balances[Dead] - _balances[address(this)];
      uint portionControl = (availableSupply/1000) * portionLimit;
      if(amount >= portionControl) {
        tax = _portionTax;
      } else {
        tax = _sellTax;
        if(enabledImpactTreshold) {
            if(impact > impactTreshold) {
                tax = tax + ((3 * impact)/2 - impactTreshold  );
            }
        }
      }
    } else if (isBuy) { 
	 if (!_excludedFromSellLock[sender]) {
        require(
          _sellLock[sender] <= block.timestamp || sellLockDisabled,
          "Seller in sellLock"
        );

        _sellLock[sender] = block.timestamp + sellLockTime;
      }
      require(amount <= sellLimit, "Dump protection");
      if (!isBalanceFree[recipient]) {
        require(recipientBalance + amount <= balanceLimit, "whale protection");
      }
      tax = _buyTax;
    } else {
      if (!isBalanceFree[recipient]) {
        require(recipientBalance + amount <= balanceLimit, "whale protection");
      }
      require(recipientBalance + amount <= balanceLimit, "whale protection");

      if (!_excludedFromSellLock[sender])
        require(
          _sellLock[sender] <= block.timestamp || sellLockDisabled,
          "Sender in Lock"
        ); 
      tax = _transferTax;
    }

    if (
      (sender != _UniswapPairAddress) &&
      (!manualConversion) &&
      (!_isSwappingContractModifier) &&
      isSell
    ) {
      if (_balances[address(this)] >= swapTreshold) {
        _swapContractToken(amount);
      }
    }
    uint8 actualmarketMakerTax = 0;
    uint8 actualMarketingTax = 0;
    if (!isMarketingTaxFree[sender]) {
      actualMarketingTax = _marketingTax;
    }
    if (!isMarketMakerTaxFree[sender]) {
      actualmarketMakerTax = _marketMakerTax;
    }
    uint8 stakeTax;
    if (slot == 0) {
      stakeTax = _stakeTax_one;
    } else if (slot == 1) {
      stakeTax = _stakeTax_two;
    }

    uint256 contractToken = _calculateFee(
      amount,
      tax,
        _liquidityTax +
        actualMarketingTax +
        actualmarketMakerTax +
        _stakeTax_one +
        _stakeTax_two
    );
    uint256 taxedAmount = amount - (contractToken);

    _removeToken(sender, amount, slot);

    _balances[address(this)] += contractToken;

    _addToken(recipient, taxedAmount, slot);

    emit Transfer(sender, recipient, taxedAmount);
  }

  function _feelessTransfer(
    address sender,
    address recipient,
    uint256 amount,
    uint8 slot
  ) private {
    uint256 senderBalance = _balances[sender];
    require(senderBalance >= amount, "Transfer exceeds balance");

    _removeToken(sender, amount, slot);

    _addToken(recipient, amount, slot);

    emit Transfer(sender, recipient, amount);
  }

  function _calculateFee(
    uint256 amount,
    uint8 tax,
    uint8 taxPercent
  ) private pure returns (uint256) {
    return (amount * tax * taxPercent) / 10000;
  }

  bool private _isWithdrawing;
  uint256 private constant DistributionMultiplier = 2**64;
  mapping(uint8 => uint256) public profitPerShare;
  uint256 public totalDistributingReward;
  uint256 public oneDistributingReward;
  uint256 public twoDistributingReward;
  uint256 public totalPayouts;
  uint256 public marketingBalance;
  uint256 public marketMakerBalance;
  mapping(uint8 => uint256) rewardBalance;
  mapping(address => mapping(uint256 => uint256)) private alreadyPaidShares;
  mapping(address => uint256) private toERCaid;

  function isExcludedFromDistributing(address addr) public view returns (bool) {
    return _excludedFromDistributing[addr];
  }

  function _getTotalShares() public view returns (uint256) {
    uint256 shares = _circulatingSupply;
    shares -=  excludedAmount;
    return shares;
  }

  function _addToken(
    address addr,
    uint256 amount,
    uint8 slot
  ) private {
    uint256 newAmount = _balances[addr] + amount;

    if (_excludedFromDistributing[addr]) {
      _balances[addr] = newAmount;
      return;
    }

    uint256 payment = _newDividentsOf(addr, slot);

    alreadyPaidShares[addr][slot] = profitPerShare[slot] * newAmount;

    toERCaid[addr] += payment;

    _balances[addr] = newAmount;
  }

  function _removeToken(
    address addr,
    uint256 amount,
    uint8 slot
  ) private {
    uint256 newAmount = _balances[addr] - amount;

    if (_excludedFromDistributing[addr]) {
      _balances[addr] = newAmount;
      return;
    }

    uint256 payment = _newDividentsOf(addr, slot);

    _balances[addr] = newAmount;

    alreadyPaidShares[addr][slot] = profitPerShare[slot] * newAmount;

    toERCaid[addr] += payment;
  }

  function _newDividentsOf(address staker, uint8 slot)
    private
    view
    returns (uint256)
  {
    uint256 fullPayout = profitPerShare[slot] * _balances[staker];

    if (fullPayout < alreadyPaidShares[staker][slot]) return 0;
    return
      (fullPayout - alreadyPaidShares[staker][slot]) / DistributionMultiplier;
  }

  function _distributeStake(uint256 ETHamount) private {
    uint256 marketingSplit = (ETHamount * _marketingTax) / 100;
    uint256 marketMakerSplit = (ETHamount * _marketMakerTax) / 100;
    uint256 amount_one = (ETHamount * _stakeTax_one) / 100;
    uint256 amount_two = (ETHamount * _stakeTax_two) / 100;
    marketingBalance += marketingSplit;
    marketMakerBalance += marketMakerSplit;

    if (amount_one > 0) {
      totalDistributingReward += amount_one;
      oneDistributingReward += amount_one;
      uint256 totalShares = _getTotalShares();
      if (totalShares == 0) {
        marketingBalance += amount_one;
      } else {
        profitPerShare[0] += ((amount_one * DistributionMultiplier) /
          totalShares);
        rewardBalance[0] += amount_one;
      }
    }

    if (amount_two > 0) {
      totalDistributingReward += amount_two;
      twoDistributingReward += amount_two;
      uint256 totalShares = _getTotalShares();
      if (totalShares == 0) {
        marketingBalance += amount_two;
      } else {
        profitPerShare[1] += ((amount_two * DistributionMultiplier) /
          totalShares);
        rewardBalance[1] += amount_two;
      }
    }

  }

  event OnWithdrawFarmedToken(uint256 amount, address recipient);

  ///@dev Claim tokens correspondant to a slot, if enabled
  function claimFarmedToken(
    address addr,
    address tkn,
    uint8 slot
  ) private {
    if (slot == 1) {
      require(isAuthorized[addr], "You cant retrieve it");
    }
    require(!_isWithdrawing);
    require(is_claimable[slot][tkn], "Not enabled");
    _isWithdrawing = true;
    uint256 amount;
    if (_excludedFromDistributing[addr]) {
      amount = toERCaid[addr];
      toERCaid[addr] = 0;
    } else {
      uint256 newAmount = _newDividentsOf(addr, slot);

      alreadyPaidShares[addr][slot] = profitPerShare[slot] * _balances[addr];

      amount = toERCaid[addr] + newAmount;
      toERCaid[addr] = 0;
    }
    if (amount == 0) {
      _isWithdrawing = false;
      return;
    }
    totalPayouts += amount;
    address[] memory path = new address[](2);
    path[0] = _UniswapRouter.WETH();
    path[1] = tkn;
    _UniswapRouter.swapExactETHForTokensSupportingFeeOnTransferTokens{
      value: amount
    }(0, path, addr, block.timestamp);

    emit OnWithdrawFarmedToken(amount, addr);
    _isWithdrawing = false;
  }

  uint256 public totalLPETH;
  bool private _isSwappingContractModifier;
  modifier lockTheSwap() {
    _isSwappingContractModifier = true;
    _;
    _isSwappingContractModifier = false;
  }

  function _swapContractToken(uint256 sellAmount)
    private
    lockTheSwap
  {
    uint256 contractBalance = _balances[address(this)];
    uint16 totalTax = _liquidityTax +  _stakeTax_one + _stakeTax_two;

    uint256 tokenToSwap = (sellLimit * 10) / 100;
    if (manualTokenToSwap) {
      tokenToSwap = manualQtyTokenToSwap;
    } 

    bool prevSellPeg = sellPeg;
    if (sellPeg) {
      if (tokenToSwap > sellAmount) {
        tokenToSwap = sellAmount / 2;
      }
    }
    sellPeg = prevSellPeg;
    if (sellAll) {
    tokenToSwap = contractBalance - 1;
  }
    

    if (contractBalance < tokenToSwap || totalTax == 0) {
      return;
    }

    uint256 tokenForLiquidity = (tokenToSwap * _liquidityTax) / totalTax;
    uint256 tokenForMarketing = (tokenToSwap * _marketingTax) / totalTax;
    uint256 tokenForMarketMaker = (tokenToSwap * _marketMakerTax) / totalTax;
    uint256 swapToken = tokenForLiquidity +
      tokenForMarketing +
      tokenForMarketMaker;
    // Avoid solidity imprecisions
    if (swapToken >= tokenToSwap) {
      tokenForMarketMaker -= (tokenToSwap - (swapToken));
    }

    uint256 liqToken = tokenForLiquidity / 2;
    uint256 liqETHToken = tokenForLiquidity - liqToken;

    swapToken = liqETHToken + tokenForMarketing + tokenForMarketMaker;

    uint256 initialETHBalance = address(this).balance;
    _swapTokenForETH(swapToken);
    uint256 newETH = (address(this).balance - initialETHBalance);

    uint256 liqETH = (newETH * liqETHToken) / swapToken;
    _addLiquidity(liqToken, liqETH);

    _distributeStake(address(this).balance - initialETHBalance);
  }

  function _swapTokenForETH(uint256 amount) private {
    _approve(address(this), address(_UniswapRouter), amount);
    address[] memory path = new address[](2);
    path[0] = address(this);
    path[1] = _UniswapRouter.WETH();
    _UniswapRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(
      amount,
      0,
      path,
      address(this),
      block.timestamp
    );
  }

  function _addLiquidity(uint256 tokenamount, uint256 ETHamount) private {
    totalLPETH += ETHamount;
    _approve(address(this), address(_UniswapRouter), tokenamount);
    _UniswapRouter.addLiquidityETH{value: ETHamount}(
      address(this),
      tokenamount,
      0,
      0,
      address(this),
      block.timestamp
    );
  }

  function getLimits() public view returns (uint256 balance, uint256 sell) {
    return (balanceLimit / 10**_decimals, sellLimit / 10**_decimals);
  }

  function getTaxes()
    public
    view
    returns (
      uint256 marketingTax,
      uint256 marketMakerTax,
      uint256 liquidityTax,
      uint256 stakeTax_one,
        uint256 stakeTax_two,
 uint256 buyTax,
      uint256 sellTax,
      uint256 transferTax
    )
  {
    return (
      _marketingTax,
      _marketMakerTax,
      _liquidityTax,
      _stakeTax_one,
      _stakeTax_two,
      _buyTax,
      _sellTax,
      _transferTax
    );
  }

  function getWhitelistedStatus(address AddressToCheck)
    public
    view
    returns (bool)
  {
    return _whiteList[AddressToCheck];
  }

  function getAddressSellLockTimeInSeconds(address AddressToCheck)
    public
    view
    returns (uint256)
  {
    uint256 lockTime = _sellLock[AddressToCheck];
    if (lockTime <= block.timestamp) {
      return 0;
    }
    return lockTime - block.timestamp;
  }

  function getSellLockTimeInSeconds() public view returns (uint256) {
    return sellLockTime;
  }

  ///@dev Reset cooldown for an address
  function AddressResetSellLock() public {
    _sellLock[msg.sender] = block.timestamp + sellLockTime;
  }

  ///@dev Retrieve slot 1
  function FarmedTokenWithdrawSlotOne(address tkn) public {
    claimFarmedToken(msg.sender, tkn, 0);
  }

  
  ///@dev Retrieve slot 2
  function FarmedTokenWithdrawSlotTwo(address tkn) public {
    claimFarmedToken(msg.sender, tkn, 1);
  }

  function getDividends(address addr, uint8 slot)
    public
    view
    returns (uint256)
  {
    if (_excludedFromDistributing[addr]) return toERCaid[addr];
    return _newDividentsOf(addr, slot) + toERCaid[addr];
  }

  bool public sellLockDisabled;
  uint256 public sellLockTime;
  bool public manualConversion;
 
  ///@dev Airdrop tokens
  function airdropAddresses(
    address[] memory addys,
    address token,
    uint256 qty
  ) public onlyAuth {
    uint256 single_drop = qty / addys.length;
    IERC20 airtoken = IERC20(token);
    bool sent;
    for (uint256 i; i <= (addys.length - 1); i++) {
      sent = airtoken.transfer(addys[i], single_drop);
      require(sent);
      sent = false;
    }
  }

  ///@dev Airdrop a N of addresses
  function airdropAddressesNative(address[] memory addys)
    public
    payable
    onlyAuth
  {
    uint256 qty = msg.value;
    uint256 single_drop = qty / addys.length;
    bool sent;
    for (uint256 i; i <= (addys.length - 1); i++) {
      sent = payable(addys[i]).send(single_drop);
      require(sent);
      sent = false;
    }
  }

  ///@dev Enable pools for a token
  function ControlEnabledClaims(
    uint8 slot,
    address tkn,
    bool booly
  ) public onlyAuth {
    is_claimable[slot][tkn] = booly;
  }

  ///@dev Rekt all the snipers
  function ControlBotKiller(bool booly) public onlyAuth {
    botKiller = booly;
  }

  ///@dev Minimum tokens to sell
  function ControlSetSwapTreshold(uint256 treshold) public onlyAuth {
    swapTreshold = treshold * 10**_decimals;
  }

  ///@dev Exclude from distribution
  function ControlExcludeFromDistributing(address addr, uint8 slot)
    public
    onlyAuth
  {
    require(_excludedFromDistributing[addr]);
    uint256 newDividents = _newDividentsOf(addr, slot);
    alreadyPaidShares[addr][slot] = _balances[addr] * profitPerShare[slot];
    toERCaid[addr] += newDividents;
    _excludedFromDistributing[addr] = true;
    excludedAmount += _balances[addr];
  }

  ///@dev Include into distribution
  function ControlIncludeToDistributing(address addr, uint8 slot)
    public
    onlyAuth
  {
    require(_excludedFromDistributing[addr]);
    _excludedFromDistributing[addr] = false;
    excludedAmount -= _balances[addr];

    alreadyPaidShares[addr][slot] = _balances[addr] * profitPerShare[slot];
  }

  ///@dev Take out the marketing balance
  function ControlWithdrawMarketingETH() public onlyAuth {
    uint256 amount = marketingBalance;
    marketingBalance = 0;
    (bool sent, ) = marketingWallet.call{value: (amount)}("");
    require(sent, "withdraw failed");
  }

  ///@dev Peg sells to the tx
  function ControlSwapSetSellPeg(bool setter) public onlyAuth {
    sellPeg = setter;
  }

  ///@dev Set marketing tax free or not
  function ControlSetMarketingTaxFree(address addy, bool booly)
    public
    onlyAuth
  {
    isMarketingTaxFree[addy] = booly;
  }

  ///@dev Set an address into or out marketmaker fee
  function ControlSetMarketMakerTaxFree(address addy, bool booly)
    public
    onlyAuth
  {
    isMarketMakerTaxFree[addy] = booly;
  }

  ///@dev Disable tax reward for address
  function ControlSetRewardTaxFree(address addy, bool booly) public onlyAuth {
    isRewardTaxFree[addy] = booly;
  }

  ///@dev Disable address balance limit
  function ControlSetBalanceFree(address addy, bool booly) public onlyAuth {
    isBalanceFree[addy] = booly;
  }

  ///@dev Enable or disable manual sell
  function ControlSwapSetManualLiqSell(bool setter) public onlyAuth {
    manualTokenToSwap = setter;
  }

  ///@dev Turn sells into manual
  function ControlSwapSetManualLiqSellTokens(uint256 amount) public onlyAuth {
    require(amount > 1 && amount < 100000000, "Values between 1 and 100000000");
    manualQtyTokenToSwap = amount * 10**_decimals;
  }

  ///@dev Disable auto sells
  function ControlSwapSwitchManualETHConversion(bool manual) public onlyAuth {
    manualConversion = manual;
  }

  ///@dev Set cooldown on or off (ONCE)
  function ControlDisableSellLock(bool disabled) public onlyAuth {
    sellLockDisabled = disabled;
  }

  ///@dev Set cooldown
  function ControlSetSellLockTime(uint256 sellLockSeconds) public onlyAuth {
    require(sellLockSeconds <= MaxSellLockTime, "Sell Lock time too high");
    sellLockTime = sellLockSeconds;
  }


  ///@dev Set taxes
  function ControlSetTaxes(
    uint8 buyTax,
    uint8 sellTax,
    uint8 portionTax,
    uint8 transferTax
  ) public onlyAuth {
    require(
      buyTax <= MaxTax && sellTax <= MaxTax && transferTax <= MaxTax,
      "taxes higher than max tax"
    );

    _buyTax = buyTax;
    _sellTax = sellTax;
    _portionTax = portionTax;
    _transferTax = transferTax;
  }

  function ControlSetShares(
    uint8 marketingTaxes,
    uint8 marketMakerTaxes,
    uint8 liquidityTaxes,
    uint8 stakeTaxes_one,
    uint8 stakeTaxes_two) public onlyAuth {

     uint8 totalTax = marketingTaxes +
      marketMakerTaxes +
      liquidityTaxes +
      stakeTaxes_one +
      stakeTaxes_two;
    require(totalTax == 100, "total taxes needs to equal 100%");

    require(marketingTaxes <= 55, "Max 55%");
    require(marketMakerTaxes <= 55, "Max 45%");
    require(stakeTaxes_one <= 55, "Max 45%");
    require(stakeTaxes_two <= 55, "Max 45%");

    _marketingTax = marketingTaxes;
    _marketMakerTax = marketMakerTaxes;
    _liquidityTax = liquidityTaxes;
    _stakeTax_one = stakeTaxes_one;
    _stakeTax_two = stakeTaxes_two;
  }
function SetPortionLimit(uint256 _portionlimit) public onlyAuth { 
	 portionLimit = _portionlimit ;
  }
  ///@dev Manually sell and create LP
  function ControlCreateLPandETH() public onlyAuth {
    _swapContractToken(192919291929192919291929192919291929);
  }

  ///@dev Manually sell all tokens gathered
  function ControlSellAllTokens() public onlyAuth {
    sellAll = true;
    _swapContractToken(192919291929192919291929192919291929);
    sellAll = false;
  }

  ///@dev Free from fees
  function ControlExcludeAccountFromFees(address account) public onlyAuth {
    _excluded[account] = true;
  }

  ///@dev Include in fees
  function ControlIncludeAccountToFees(address account) public onlyAuth {
    _excluded[account] = true;
  }

  ///@dev Exclude from cooldown
  function ControlExcludeAccountFromSellLock(address account) public onlyAuth {
    _excludedFromSellLock[account] = true;
  }

  ///@dev Enable cooldown
  function ControlIncludeAccountToSellLock(address account) public onlyAuth {
    _excludedFromSellLock[account] = true;
  }

  ///@dev Enable or disable pool 2 for an address
  function ControlIncludeAccountToSubset(address account, bool booly)
    public
    onlyAuth
  {
    isAuthorized[account] = booly;
  }

  ///@dev Control all the tx, buy and sell limits
  function ControlUpdateLimits(uint256 newBalanceLimit, uint256 newSellLimit)
    public
    onlyAuth
  {
    newBalanceLimit = newBalanceLimit * 10**_decimals;
    newSellLimit = newSellLimit * 10**_decimals;

   
    balanceLimit = newBalanceLimit;
    sellLimit = newSellLimit;
  }

  bool public tradingEnabled;
  address private _liquidityTokenAddress;


  function setMarketingWallet(address addy) public onlyAuth {
    marketingWallet = addy;
    _excludedFromSellLock[marketingWallet] = true;
  }
  function setMarketMakingWallet(address addy) public onlyAuth {
    marketMakerWallet = addy;
    _excludedFromSellLock[marketMakerWallet] = true;
  }
    function setSlotOneWallet(address addy) public onlyAuth {
    rewardWallet_one = addy;
    _excludedFromSellLock[rewardWallet_one] = true;
  }
    function setSlotTwoWallet(address addy) public onlyAuth {
    rewardWallet_two = addy;
    _excludedFromSellLock[rewardWallet_two] = true;
  }

  ///@dev Start/stop trading
  function SetupEnableTrading(bool booly) public onlyAuth {
    tradingEnabled = booly;
  }

  ///@dev Define a new liquidity pair
  function SetupLiquidityTokenAddress(address liquidityTokenAddress)
    public
    onlyAuth
  {
    _liquidityTokenAddress = liquidityTokenAddress;
  }

  ///@dev Add to WL
  function SetupAddToWhitelist(address addressToAdd) public onlyAuth {
    _whiteList[addressToAdd] = true;
  }

  ///@dev Remove from whitelist
  function SetupRemoveFromWhitelist(address addressToRemove) public onlyAuth {
    _whiteList[addressToRemove] = false;
  }

  ///@dev Take back tokens stuck into the contract
  function rescueTokens(address tknAddress) public onlyAuth {
    IERC20 token = IERC20(tknAddress);
    uint256 ourBalance = token.balanceOf(address(this));
    require(ourBalance > 0, "No tokens in our balance");
    token.transfer(msg.sender, ourBalance);
  }

  ///@dev Disable PERMANENTLY blacklist functions
  function disableBlacklist() public onlyAuth {
    isBlacklist = false;
  }

  ///@dev Blacklist someone
  function setBlacklistedAddress(address toBlacklist) public onlyAuth {
    _blacklist[toBlacklist] = true;
  }

  ///@dev Remove from blacklist
  function removeBlacklistedAddress(address toRemove) public onlyAuth {
    _blacklist[toRemove] = false;
  }

  ///@dev Block or unblock an address
 /* function setisOpen(address addy, bool booly) public onlyAuth {
    isOpen[addy] = booly;
  }*/
    function setisOpenArry(address[] calldata addy, bool[] calldata booly) public onlyAuth {
        for(uint256 i; i < addy.length; i++){
            isOpen[addy[i]] = booly[i];
        }
        }

  function setImpactTreshold(uint8 inty) public onlyAuth {
      impactTreshold = inty;
  }

  function enableImpactTreshold(bool booly) public onlyAuth {
      enabledImpactTreshold = booly;
  }

  ///@dev Remove the balance remaining in the contract
  function ControlRemoveRemainingETH() public onlyAuth {
    (bool sent, ) = owner.call{value: (address(this).balance)}("");
    require(sent);
  }

  receive() external payable {}

  fallback() external payable {}

  function getowner() external view override returns (address) {
    return owner;
  }

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

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

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

  function totalSupply() external view override returns (uint256) {
    return _circulatingSupply;
  }

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

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

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

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

  function _approve(
    address _owner,
    address spender,
    uint256 amount
  ) private {
    require(_owner != address(0), "Approve from zero");
    require(spender != address(0), "Approve to zero");
    _allowances[_owner][spender] = amount;
    emit Approval(_owner, spender, amount);
  }

  function transferFrom(
    address sender,
    address recipient,
    uint256 amount
  ) external override returns (bool) {
    _transfer(sender, recipient, amount);
    uint256 currentAllowance = _allowances[sender][msg.sender];
    require(currentAllowance >= amount, "Transfer > allowance");
    _approve(sender, msg.sender, currentAllowance - amount);
    return true;
  }

  function increaseAllowance(address spender, uint256 addedValue)
    external
    returns (bool)
  {
    _approve(
      msg.sender,
      spender,
      _allowances[msg.sender][spender] + addedValue
    );
    return true;
  }

  function decreaseAllowance(address spender, uint256 subtractedValue)
    external
    returns (bool)
  {
    uint256 currentAllowance = _allowances[msg.sender][spender];
    require(currentAllowance >= subtractedValue, "<0 allowance");
    _approve(msg.sender, spender, currentAllowance - subtractedValue);
    return true;
  }

}