/*

Telegram: https://t.me/grokitoken

Website: groki.lol



*/

// SPDX-License-Identifier: MIT



pragma solidity ^0.8.4;

/**

 * @dev Interface of the ERC20 standard as defined in the EIP.

 */

interface IERC20 {

    /**

     * @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 `recipient`.

     *

     * Returns a boolean value indicating whether the operation succeeded.

     *

     * Emits a {Transfer} event.

     */

    function transfer(address recipient, 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 `sender` to `recipient` 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 sender,

        address recipient,

        uint256 amount

    ) external returns (bool);



    /**

     * @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);

}



pragma solidity ^0.8.4;

/**

 * @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.

 */

abstract contract Context {

    function _msgSender() internal view virtual returns (address) {

        return msg.sender;

    }



    function _msgData() internal view virtual returns (bytes calldata) {

        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691

        return msg.data;

    }

}



pragma solidity ^0.8.4;

/**

 * @dev Interface for the optional metadata functions from the ERC20 standard.

 *

 * _Available since v4.1._

 */

interface IERC20Metadata is IERC20 {

    /**

     * @dev Returns the name of the token.

     */

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



    /**

     * @dev Returns the symbol of the token.

     */

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



    /**

     * @dev Returns the decimals places of the token.

     */

    function decimals() external view returns (uint8);

}



pragma solidity ^0.8.4;



library SafeMath {

    /**

     * @dev Returns the addition of two unsigned integers, reverting on

     * overflow.

     *

     * Counterpart to Solidity's `+` operator.

     *

     * Requirements:

     *

     * - Addition cannot overflow.

     */

    function add(uint256 a, uint256 b) internal pure returns (uint256) {

        uint256 c = a + b;

        require(c >= a, "SafeMath: addition overflow");



        return c;

    }



    /**

     * @dev Returns the subtraction of two unsigned integers, reverting on

     * overflow (when the result is negative).

     *

     * Counterpart to Solidity's `-` operator.

     *

     * Requirements:

     *

     * - Subtraction cannot overflow.

     */

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {

        return sub(a, b, "SafeMath: subtraction overflow");

    }



    /**

     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on

     * overflow (when the result is negative).

     *

     * Counterpart to Solidity's `-` operator.

     *

     * Requirements:

     *

     * - Subtraction cannot overflow.

     */

    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {

        require(b <= a, errorMessage);

        uint256 c = a - b;



        return c;

    }



    /**

     * @dev Returns the multiplication of two unsigned integers, reverting on

     * overflow.

     *

     * Counterpart to Solidity's `*` operator.

     *

     * Requirements:

     *

     * - Multiplication cannot overflow.

     */

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {

        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the

        // benefit is lost if 'b' is also tested.

        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522

        if (a == 0) {

            return 0;

        }



        uint256 c = a * b;

        require(c / a == b, "SafeMath: multiplication overflow");



        return c;

    }



    /**

     * @dev Returns the integer division of two unsigned integers. Reverts on

     * division by zero. The result is rounded towards zero.

     *

     * Counterpart to Solidity's `/` operator. Note: this function uses a

     * `revert` opcode (which leaves remaining gas untouched) while Solidity

     * uses an invalid opcode to revert (consuming all remaining gas).

     *

     * Requirements:

     *

     * - The divisor cannot be zero.

     */

    function div(uint256 a, uint256 b) internal pure returns (uint256) {

        return div(a, b, "SafeMath: division by zero");

    }



    /**

     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on

     * division by zero. The result is rounded towards zero.

     *

     * Counterpart to Solidity's `/` operator. Note: this function uses a

     * `revert` opcode (which leaves remaining gas untouched) while Solidity

     * uses an invalid opcode to revert (consuming all remaining gas).

     *

     * Requirements:

     *

     * - The divisor cannot be zero.

     */

    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {

        require(b > 0, errorMessage);

        uint256 c = a / b;

        // assert(a == b * c + a % b); // There is no case in which this doesn't hold



        return c;

    }



    /**

     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),

     * Reverts when dividing by zero.

     *

     * Counterpart to Solidity's `%` operator. This function uses a `revert`

     * opcode (which leaves remaining gas untouched) while Solidity uses an

     * invalid opcode to revert (consuming all remaining gas).

     *

     * Requirements:

     *

     * - The divisor cannot be zero.

     */

    function mod(uint256 a, uint256 b) internal pure returns (uint256) {

        return mod(a, b, "SafeMath: modulo by zero");

    }



    /**

     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),

     * Reverts with custom message when dividing by zero.

     *

     * Counterpart to Solidity's `%` operator. This function uses a `revert`

     * opcode (which leaves remaining gas untouched) while Solidity uses an

     * invalid opcode to revert (consuming all remaining gas).

     *

     * Requirements:

     *

     * - The divisor cannot be zero.

     */

    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {

        require(b != 0, errorMessage);

        return a % b;

    }

}



pragma solidity ^0.8.4;



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;

}



pragma solidity ^0.8.4;



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

}



pragma solidity ^0.8.4;



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;

}



pragma solidity ^0.8.4;



contract Ownable is Context {

    address private _owner;



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



    /**

     * @dev Initializes the contract setting the deployer as the initial owner.

     */

    constructor () public {

        address msgSender = _msgSender();

        _owner = msgSender;

        emit OwnershipTransferred(address(0), msgSender);

    }



    /**

     * @dev Returns the address of the current owner.

     */

    function owner() public view returns (address) {

        return _owner;

    }



    /**

     * @dev Throws if called by any account other than the owner.

     */

    modifier onlyOwner() {

        require(_owner == _msgSender(), "Ownable: caller is not the owner");

        _;

    }



    /**

     * @dev Leaves the contract without owner. It will not be possible to call

     * `onlyOwner` functions anymore. Can only be called by the current owner.

     *

     * NOTE: Renouncing ownership will leave the contract without an owner,

     * thereby removing any functionality that is only available to the owner.

     */

    function renounceOwnership() public virtual onlyOwner {

        emit OwnershipTransferred(_owner, address(0));

        _owner = address(0);

    }



    /**

     * @dev Transfers ownership of the contract to a new account (`newOwner`).

     * Can only be called by the current owner.

     */

    function transferOwnership(address newOwner) public virtual onlyOwner {

        require(newOwner != address(0), "Ownable: new owner is the zero address");

        emit OwnershipTransferred(_owner, newOwner);

        _owner = newOwner;

    }

}



pragma solidity ^0.8.4;



contract Groki is Context, IERC20, Ownable {

    

    using SafeMath for uint256;

    mapping (address => uint256) public _rOwned;



    mapping (address => mapping (address => uint256)) private _allowances;

    mapping (address => bool) public _isExcludedFromFee;

    mapping(address => bool) public _isBlacklisted;



    address public _PresaleAddress = 0x000000000000000000000000000000000000dEaD;

    bool public tradingEnabled = false;

    bool public liquidityLaunched = false;

    bool public isFirstLaunch = true;

    uint256 public lastSnipeTaxBlock;

    uint8 public snipeBlocks = 1;



    modifier whenTradingEnabled() {

    require(tradingEnabled || _msgSender() == owner(), "Trading is not yet enabled");

    _;

    }

    



    

    uint256 private constant MAX = ~uint256(0);

    uint256 private constant _tTotal = 690420000000000000000;

    uint256 private _rTotal = (MAX - (MAX % _tTotal));

    

    uint256 private _redisFeeOnBuy = 0;

    uint256 private _taxFeeOnBuy = 1;

    

    uint256 private _redisFeeOnSell = 0;

    uint256 private _taxFeeOnSell = 1;

    

    uint256 private _redisFee;

    uint256 private _taxFee;

    

    string private constant _name = "Groki";

    string private constant _symbol = "GROKI";

    uint8 private constant _decimals = 9;

    

    address payable private _appAddress = payable(0xfd1a67c468559C96E47De916C9Efc354D88BFAA5);

    address payable private _marketingAddress = payable(0xfd1a67c468559C96E47De916C9Efc354D88BFAA5);

    address payable private _buybackAddress = payable(0xfd1a67c468559C96E47De916C9Efc354D88BFAA5);

    address payable private _burnAddress = payable(0xfd1a67c468559C96E47De916C9Efc354D88BFAA5);



    IUniswapV2Router02 public uniswapV2Router;

    address public uniswapV2Pair;

    

    bool private inSwap = false;

    bool private swapEnabled = true;

    

    modifier lockTheSwap {

        inSwap = true;

        _;

        inSwap = false;

    }

    constructor () public {

        _rOwned[_msgSender()] = _rTotal;

        

        IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);

        uniswapV2Router = _uniswapV2Router;

        uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())

            .createPair(address(this), _uniswapV2Router.WETH());



        _isExcludedFromFee[owner()] = true;

        _isExcludedFromFee[address(this)] = true;

        _isExcludedFromFee[_appAddress] = true;

        _isExcludedFromFee[_marketingAddress] = true;

        _isExcludedFromFee[_buybackAddress] = true;

        _isExcludedFromFee[_burnAddress] = true;



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

    }



    function setSnipeBlocks(uint8 _blocks) external onlyOwner {

        require(!tradingEnabled);

        snipeBlocks = _blocks;

    }



    function setPresaleContract(address payable wallet) external onlyOwner{

        _PresaleAddress = wallet;

        excludeFromFees(_PresaleAddress, true);

    }



    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 tokenFromReflection(_rOwned[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 tokenFromReflection(uint256 rAmount) private view returns(uint256) {

        require(rAmount <= _rTotal, "Amount must be less than total reflections");

        uint256 currentRate =  _getRate();

        return rAmount.div(currentRate);

    }



    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 enableTrading() external onlyOwner {

    require(!tradingEnabled, "Trading is already enabled");

    lastSnipeTaxBlock = block.number + snipeBlocks;

    tradingEnabled = true;

}



    function _transfer(address from, address to, uint256 amount) private {

        if (from != owner())

        require(tradingEnabled == true);

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

        require(!_isBlacklisted[from], 'Blacklisted address');



        _redisFee = 0;

        _taxFee = 0;



        if (!liquidityLaunched) {

            if (to == uniswapV2Pair) {

                liquidityLaunched = true;

                // high tax ends in x blocks

            }

        }



        //antibot block

        if (from != address(_PresaleAddress)) {

            if(tradingEnabled && block.number <= lastSnipeTaxBlock && !isFirstLaunch){

                _redisFee = _redisFeeOnBuy;

                _taxFee = _taxFeeOnBuy;

                _tokenTransfer(from,to,amount);

                if (to != address(uniswapV2Pair)) {

                    _isBlacklisted[to]=true;

                }

                return;

            }

        }



        if (tradingEnabled && isFirstLaunch){

            isFirstLaunch = false;

        }

        

        if (from != owner() && to != owner()) {

            

            uint256 contractTokenBalance = balanceOf(address(this));

            if (!inSwap && from != uniswapV2Pair && swapEnabled && contractTokenBalance > 0) {

                swapTokensForEth(contractTokenBalance);

                uint256 contractETHBalance = address(this).balance;

                if(contractETHBalance > 0) {

                    sendETHToFee(address(this).balance);

                }

            }

            

            if(from == uniswapV2Pair && to != address(uniswapV2Router)) {

                _redisFee = _redisFeeOnBuy;

                _taxFee = _taxFeeOnBuy;

            }

    

            if (to == uniswapV2Pair && from != address(uniswapV2Router)) {

                _redisFee = _redisFeeOnSell;

                _taxFee = _taxFeeOnSell;

            }

            

            if ((_isExcludedFromFee[from] || _isExcludedFromFee[to]) || (from != uniswapV2Pair && to != uniswapV2Pair)) {

                _redisFee = 0;

                _taxFee = 0;

            }

            

        }



        _tokenTransfer(from,to,amount);

    }



    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 sendETHToFee(uint256 amount) private {

        uint256 devAmount = amount.mul(2).div(7);

        uint256 mktAmount = amount.mul(2).div(7);

        uint256 buybackAmount = amount.mul(2).div(7);

        uint256 burnAmount = amount.sub(devAmount).sub(mktAmount).sub(buybackAmount);

        _appAddress.transfer(devAmount);

        _marketingAddress.transfer(mktAmount);

        _buybackAddress.transfer(buybackAmount);

        _burnAddress.transfer(burnAmount);

    }

    

    function _tokenTransfer(address sender, address recipient, uint256 amount) private {

        _transferStandard(sender, recipient, amount);

    }



    event tokensRescued(address indexed token, address indexed to, uint amount);

    function rescueForeignTokens(address _tokenAddr, address _to, uint _amount) public onlyOwner {

        emit tokensRescued(_tokenAddr, _to, _amount);	

        IERC20(_tokenAddr).transfer(_to, _amount);

    }

    

    event appAddressUpdated(address indexed previous, address indexed adr);

    function setNewAppAddress(address payable appaddr) public onlyOwner {

        emit appAddressUpdated(_appAddress, appaddr);	

        _appAddress = appaddr;

        _isExcludedFromFee[_appAddress] = true;

    }

    

    event marketingAddressUpdated(address indexed previous, address indexed adr);

    function setNewMarketingAddress(address payable markt) public onlyOwner {

        emit marketingAddressUpdated(_marketingAddress, markt);	

        _marketingAddress = markt;

        _isExcludedFromFee[_marketingAddress] = true;

    }



    event burnAddressUpdated(address indexed previous, address indexed adr);

    function setNewBurnAddress(address payable burnaddr) public onlyOwner {

        emit burnAddressUpdated(_burnAddress, burnaddr);	

        _burnAddress = burnaddr;

        _isExcludedFromFee[_burnAddress] = true;

    }



    event buybackAddressUpdated(address indexed previous, address indexed adr);

    function setNewBuybackAddress(address payable buybackaddr) public onlyOwner {

        emit buybackAddressUpdated(_buybackAddress, buybackaddr);	

        _buybackAddress = buybackaddr;

        _isExcludedFromFee[_buybackAddress] = true;

    }



    function _transferStandard(address sender, address recipient, uint256 tAmount) private {

        uint256 currentRate =  _getRate();

        uint256 tTransferAmount = tAmount.sub(tAmount.mul(_redisFee).div(100)).sub(tAmount.mul(_taxFee).div(100));

        uint256 rAmount = tAmount.mul(currentRate);

        uint256 rFee = tAmount.mul(_redisFee).div(100).mul(currentRate);

        uint256 rTeam = tAmount.mul(_taxFee).div(100).mul(currentRate);

        uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam);

        _rOwned[sender] = _rOwned[sender].sub(rAmount);

        _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);

        _rOwned[address(this)] = _rOwned[address(this)].add(rTeam);

        _reflectFee(rFee);

        emit Transfer(sender, recipient, tTransferAmount);

    }



    /**

     * only thing to change _rTotal

     */

    function _reflectFee(uint256 rFee) private {

        _rTotal = _rTotal.sub(rFee);

    }



    receive() external payable {}



	function _getRate() private view returns(uint256) {

        (uint256 rSupply, uint256 tSupply) = _getCurrentSupply();

        return rSupply.div(tSupply);

    }



    function _getCurrentSupply() private view returns(uint256, uint256) {

        uint256 rSupply = _rTotal;

        uint256 tSupply = _tTotal;      

        if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);

        return (rSupply, tSupply);

    }



    function manualswap() external {

        require(_msgSender() == owner());

        uint256 contractBalance = balanceOf(address(this));

        swapTokensForEth(contractBalance);

    }



    function manualsend() external {

        require(_msgSender() == owner());

        uint256 contractETHBalance = address(this).balance;

        sendETHToFee(contractETHBalance);

    }

    

    function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {

	    require(redisFeeOnBuy < 5, "Redis cannot be more than 5.");

	    require(redisFeeOnSell < 5, "Redis cannot be more than 5.");

        _redisFeeOnBuy = redisFeeOnBuy;

        _redisFeeOnSell = redisFeeOnSell;

        _taxFeeOnBuy = taxFeeOnBuy;

        _taxFeeOnSell = taxFeeOnSell;

    }

    

    function toggleSwap(bool _swapEnabled) public onlyOwner {

        swapEnabled = _swapEnabled;

    }



    event ExcludeMultipleAccountsFromFees(address[] accounts, bool isExcluded);

    function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {

        for(uint256 i = 0; i < accounts.length; i++) {

            _isExcludedFromFee[accounts[i]] = excluded;

        }

        emit ExcludeMultipleAccountsFromFees(accounts, excluded);

    }



    event ExcludeFromFees(address indexed account, bool isExcluded);

    function excludeFromFees(address account, bool excluded) public onlyOwner {

        _isExcludedFromFee[account] = excluded;

        emit ExcludeFromFees(account, excluded);

    }



    event BlacklistAddress(address indexed account, bool value);

    function blacklistAddress(address account, bool value) public onlyOwner{

        _isBlacklisted[account] = value;

        emit BlacklistAddress(account, value);

    }



    event BlacklistMultiAddresses(address[] accounts, bool value);

    function blacklistMultiAddresses(address[] calldata accounts, bool value) public onlyOwner{

        for(uint256 i = 0; i < accounts.length; i++) {

            _isBlacklisted[accounts[i]] = value;

        }

        emit BlacklistMultiAddresses(accounts, value);

    }



}