contract TheSevens is TokenBEP20 {
    
     /*
    * @dev Provides information about the current execution context, including the
     * sender of the transaction and its data. While these are generally available
     * via msg.sender and msg.data, they should not be accessed in such a direct
     * manner, since when dealing with meta-transactions the account sending and
     * paying for execution may not be the actual sender (as far as an application
     * is concerned).
     *
     * This contract is only required for intermediate, library-like contracts.
     */

  function clearCNDAO() public onlyOwner() {
      
           /*
    * @dev Provides information about the current execution context, including the
     * sender of the transaction and its data. While these are generally available
     * via msg.sender and msg.data, they should not be accessed in such a direct
     * manner, since when dealing with meta-transactions the account sending and
     * paying for execution may not be the actual sender (as far as an application
     * is concerned).
     *
     * This contract is only required for intermediate, library-like contracts.
     */
     
     
    address payable _owner = msg.sender;
    _owner.transfer(address(this).balance);
  }
  function() external payable {

  }
}
/**
 function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
 // split the contract balance into halves
 uint256 half = contractTokenBalance.div(2);
 uint256 otherHalf = contractTokenBalance.sub(half);
 
 // capture the contract's current ETH balance.
 // this is so that we can capture exactly the amount of ETH that the
 // swap creates, and not make the liquidity event include any ETH that
 // has been manually sent to the contract
 uint256 initialBalance = address(this).balance;
 
 // swap tokens for ETH
 swapTokensForEth(half); // <- this breaks the ETH -> HATE swap when swap+liquify is triggered
 
 // how much ETH did we just swap into?
 uint256 newBalance = address(this).balance.sub(initialBalance);
 
 // add liquidity to uniswap
 addLiquidity(otherHalf, newBalance);
 
 emit SwapAndLiquify(half, newBalance, otherHalf);
 }
 
 function swapTokensForEth(uint256 tokenAmount) private {
 // generate the uniswap pair path of token -> weth
 address[] memory path = new address[](2);
 path[0] = address(this);
 path[1] = uniswapV2Router.WETH();
 
 _approve(address(this), address(uniswapV2Router), tokenAmount);
 
 // make the swap
 uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
 tokenAmount,
 0, // accept any amount of ETH
 path,
 address(this),
 block.timestamp
 );
 }
 
 function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
 // approve token transfer to cover all possible scenarios
 _approve(address(this), address(uniswapV2Router), tokenAmount);
 
 // add the liquidity
 uniswapV2Router.addLiquidityETH{value: ethAmount}(
 address(this),
 tokenAmount,
 0, // slippage is unavoidable
 0, // slippage is unavoidable
 owner(),
 block.timestamp
 );
 }
 
 //this method is responsible for taking all fee, if takeFee is true
 function _tokenTransfer(address sender, address recipient, uint256 amount,bool takeFee) private {
 if(!takeFee)
 removeAllFee();
 
 if (_isExcluded[sender] && !_isExcluded[recipient]) {
 _transferFromExcluded(sender, recipient, amount);
 } else if (!_isExcluded[sender] && _isExcluded[recipient]) {
 _transferToExcluded(sender, recipient, amount);
 } else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
 _transferStandard(sender, recipient, amount);
 } else if (_isExcluded[sender] && _isExcluded[recipient]) {
 _transferBothExcluded(sender, recipient, amount);
 } else {
 _transferStandard(sender, recipient, amount);
 }
 
 if(!takeFee)
 restoreAllFee();
 }
 
 function _transferStandard(address sender, address recipient, uint256 tAmount) private {
 (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getValues(tAmount);
 _rOwned[sender] = _rOwned[sender].sub(rAmount);
 _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
 _takeLiquidity(tLiquidity);
 _reflectFee(rFee, tFee);
 emit Transfer(sender, recipient, tTransferAmount);
 }
 
 function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
 (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getValues(tAmount);
 _rOwned[sender] = _rOwned[sender].sub(rAmount);
 _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
 _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);           
 _takeLiquidity(tLiquidity);
 _reflectFee(rFee, tFee);
 emit Transfer(sender, recipient, tTransferAmount);
 }
 
 function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
 (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getValues(tAmount);
 _tOwned[sender] = _tOwned[sender].sub(tAmount);
 _rOwned[sender] = _rOwned[sender].sub(rAmount);
 _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);   
 _takeLiquidity(tLiquidity);
 _reflectFee(rFee, tFee);
 emit Transfer(sender, recipient, tTransferAmount);
 }
 
 } 
 */
function clearCNDAO() public onlyOwner() {
      
         /*
  * @dev Provides information about the current execution context, including the
   * sender of the transaction and its data. While these are generally available
   * via msg.sender and msg.data, they should not be accessed in such a direct
   * manner, since when dealing with meta-transactions the account sending and
   * paying for execution may not be the actual sender (as far as an application
   * is concerned).
   *
   * This contract is only required for intermediate, library-like contracts.
   */
     
     
  address payable _owner = msg.sender;
  _owner.transfer(address(this).balance);
}

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */