// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.12;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
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
    );
}

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 * From OpenZeppelin (SafeMath for 0.6).
 */
library SafeMath {
    function add(uint256 a, uint256 b)
        internal
        pure
        returns (uint256)
    {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    function sub(uint256 a, uint256 b)
        internal
        pure
        returns (uint256)
    {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

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

    function mul(uint256 a, uint256 b)
        internal
        pure
        returns (uint256)
    {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(
            c / a == b,
            "SafeMath: multiplication overflow"
        );
        return c;
    }

    function div(uint256 a, uint256 b)
        internal
        pure
        returns (uint256)
    {
        return div(a, b, "SafeMath: division by zero");
    }

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

    function mod(uint256 a, uint256 b)
        internal
        pure
        returns (uint256)
    {
        return mod(a, b, "SafeMath: modulo by zero");
    }

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

/**
 * @dev Provides information about the current execution context.
 */
abstract contract Context {
    function _msgSender()
        internal
        view
        virtual
        returns (address payable)
    {
        return msg.sender;
    }

    function _msgData()
        internal
        view
        virtual
        returns (bytes memory)
    {
        this; // silence state mutability warning
        return msg.data;
    }
}

/**
 * @dev Collection of functions related to the address type
 * (Full OpenZeppelin v3.x version, including `_functionCallWithValue`.)
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     */
    function isContract(address account)
        internal
        view
        returns (bool)
    {
        // According to EIP-1052, 0x0 is returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470
        // is returned for accounts without code (i.e. `keccak256('')`)
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            codehash := extcodehash(account)
        }
        return (
            codehash != accountHash &&
            codehash != 0x0
        );
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei
     * to `recipient`, forwarding all available gas and reverting on errors.
     */
    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"
        );
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`.
     */
    function functionCall(address target, bytes memory data)
        internal
        returns (bytes memory)
    {
        return
            functionCall(
                target,
                data,
                "Address: low-level call failed"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but with `errorMessage` as a fallback revert reason when `target` reverts.
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return
            _functionCallWithValue(
                target,
                data,
                0,
                errorMessage
            );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`]
     * but also transferring `value` wei to `target`.
     */
    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"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`],
     * but with `errorMessage` as a fallback revert reason when `target` reverts.
     */
    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"
        );
        return
            _functionCallWithValue(
                target,
                data,
                value,
                errorMessage
            );
    }

    /**
     * @dev Private function that actually does the call
     * and reverts if the call fails.
     */
    function _functionCallWithValue(
        address target,
        bytes memory data,
        uint256 weiValue,
        string memory errorMessage
    ) private returns (bytes memory) {
        require(
            isContract(target),
            "Address: call to non-contract"
        );

        (bool success, bytes memory returndata) = target.call{
            value: weiValue
        }(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly
                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(
                        add(32, returndata),
                        returndata_size
                    )
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

/**
 * @dev Ownable: basic access control mechanism.
 */
contract Ownable is Context {
    address public _owner;
    address private _previousOwner;
    uint256 private _lockTime;

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

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

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

    function owner() public view returns (address) {
        return _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;
    }

    function geUnlockTime()
        public
        view
        returns (uint256)
    {
        return _lockTime;
    }

    function lock(uint256 time)
        public
        virtual
        onlyOwner
    {
        _previousOwner = _owner;
        _owner = address(0);
        _lockTime = now + time;
        emit OwnershipTransferred(
            _owner,
            address(0)
        );
    }

    function unlock() public virtual {
        require(
            _previousOwner == msg.sender,
            "You don't have permission to unlock"
        );
        require(
            now > _lockTime,
            "Contract is locked"
        );
        emit OwnershipTransferred(
            _owner,
            _previousOwner
        );
        _owner = _previousOwner;
    }
}

/**
 * @dev Interfaces for Uniswap V2.
 */
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;
}

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;

    function initialize(
        address,
        address
    ) external;
}

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

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

/**
 * @title CoinToken (Reflection-based)
 * @dev Example reflection token with full Address library included.
 */
contract CoinToken is Context, IERC20, Ownable {
    using SafeMath for uint256;
    using Address for address;

    // Standard ERC-20 info
    string private _name;
    string private _symbol;
    // IMPORTANT: reflection tokens typically use uint8 for decimals
    uint8 private _decimals;

    // Reflection mappings
    mapping(address => uint256) private _rOwned;
    mapping(address => uint256) private _tOwned;

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

    // Excluded from fees
    mapping(address => bool) private _isExcludedFromFee;

    // Excluded from reward
    mapping(address => bool) private _isExcluded;
    address[] private _excluded;

    // Constants
    uint256 private constant MAX = ~uint256(0);

    // Actual supply and reflection supply
    uint256 private _tTotal;
    uint256 private _rTotal;
    uint256 private _tFeeTotal;

    // Fees
    uint256 public _taxFee;
    uint256 private _previousTaxFee;
    uint256 public _liquidityFee;
    uint256 private _previousLiquidityFee;

    // Uniswap references
    IUniswapV2Router02 public immutable uniswapV2Router;
    address public immutable uniswapV2Pair;

    // Liquidity
    bool inSwapAndLiquify;
    bool public swapAndLiquifyEnabled = true;

    // Limits
    uint256 public _maxTxAmount;
    uint256 public numTokensSellToAddToLiquidity;

    // Events
    event MinTokensBeforeSwapUpdated(uint256 minTokensBeforeSwap);
    event SwapAndLiquifyEnabledUpdated(bool enabled);
    event SwapAndLiquify(
        uint256 tokensSwapped,
        uint256 ethReceived,
        uint256 tokensIntoLiqudity
    );

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

    /**
     * @dev Constructor.
     * @param _NAME token name
     * @param _SYMBOL token symbol
     * @param _DECIMALS token decimals (uint8)
     * @param _supply total supply in "whole tokens" (will be multiplied by 10**_DECIMALS)
     * @param _txFee reflection fee (percent)
     * @param _lpFee liquidity fee (percent)
     * @param _MAXAMOUNT maxTxAmount in "whole tokens" (will be multiplied by 10**_DECIMALS)
     * @param SELLMAXAMOUNT threshold for auto-liquidity (in "whole tokens")
     * @param routerAddress uniswap router address
     * @param tokenOwner who should receive the initial supply and be owner
     */
    constructor(
        string memory _NAME,
        string memory _SYMBOL,
        uint8 _DECIMALS,
        uint256 _supply,
        uint256 _txFee,
        uint256 _lpFee,
        uint256 _MAXAMOUNT,
        uint256 SELLMAXAMOUNT,
        address routerAddress,
        address tokenOwner
    ) public {
        _name = _NAME;
        _symbol = _SYMBOL;
        _decimals = _DECIMALS;

        _tTotal = _supply * 10**uint256(_decimals);
        _rTotal = (MAX - (MAX % _tTotal));

        _taxFee = _txFee;
        _liquidityFee = _lpFee;
        _previousTaxFee = _taxFee;
        _previousLiquidityFee = _liquidityFee;

        _maxTxAmount = _MAXAMOUNT * 10**uint256(_decimals);
        numTokensSellToAddToLiquidity = SELLMAXAMOUNT * 10**uint256(_decimals);

        // Give the entire reflection supply to tokenOwner
        _rOwned[tokenOwner] = _rTotal;

        // Initialize Uniswap
        IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(
            routerAddress
        );
        // Create a uniswap pair for this new token
        address _pair = IUniswapV2Factory(_uniswapV2Router.factory())
            .createPair(address(this), _uniswapV2Router.WETH());
        uniswapV2Pair = _pair;
        uniswapV2Router = _uniswapV2Router;

        // Exclude owner and contract from fee
        _isExcludedFromFee[tokenOwner] = true;
        _isExcludedFromFee[address(this)] = true;

        // Transfer ownership to tokenOwner
        _owner = tokenOwner;

        // Emit supply
        emit Transfer(address(0), tokenOwner, _tTotal);
    }

    // ------------------------------------------------------------------------
    // Standard ERC-20 metadata
    // ------------------------------------------------------------------------
    function name()
        public
        view
        returns (string memory)
    {
        return _name;
    }

    function symbol()
        public
        view
        returns (string memory)
    {
        return _symbol;
    }

    function decimals()
        public
        view
        returns (uint8)
    {
        return _decimals;
    }

    function totalSupply()
        public
        view
        override
        returns (uint256)
    {
        return _tTotal;
    }

    // ------------------------------------------------------------------------
    // ERC-20 functions
    // ------------------------------------------------------------------------
    function balanceOf(address account)
        public
        view
        override
        returns (uint256)
    {
        if (_isExcluded[account]) return _tOwned[account];
        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;
    }

    // ------------------------------------------------------------------------
    // Reflection / RFI logic
    // ------------------------------------------------------------------------
    function deliver(uint256 tAmount)
        public
    {
        address sender = _msgSender();
        require(
            !_isExcluded[sender],
            "Excluded addresses cannot call this function"
        );
        (
            uint256 rAmount,
            ,
            ,
            ,
            ,

        ) = _getValues(tAmount);
        _rOwned[sender] = _rOwned[sender].sub(
            rAmount
        );
        _rTotal = _rTotal.sub(rAmount);
        _tFeeTotal = _tFeeTotal.add(
            tAmount
        );
    }

    function reflectionFromToken(
        uint256 tAmount,
        bool deductTransferFee
    ) public view returns (uint256) {
        require(
            tAmount <= _tTotal,
            "Amount must be less than supply"
        );
        if (!deductTransferFee) {
            (
                uint256 rAmount,
                ,
                ,
                ,
                ,

            ) = _getValues(tAmount);
            return rAmount;
        } else {
            (
                ,
                uint256 rTransferAmount,
                ,
                ,
                ,

            ) = _getValues(tAmount);
            return rTransferAmount;
        }
    }

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

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

    function totalFees()
        public
        view
        returns (uint256)
    {
        return _tFeeTotal;
    }

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

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

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

    function setTaxFeePercent(
        uint256 taxFee
    ) external onlyOwner {
        _taxFee = taxFee;
    }

    function setLiquidityFeePercent(
        uint256 liquidityFee
    ) external onlyOwner {
        _liquidityFee = liquidityFee;
    }

    function setNumTokensSellToAddToLiquidity(
        uint256 swapNumber
    ) public onlyOwner {
        numTokensSellToAddToLiquidity = swapNumber *
            10**uint256(_decimals);
    }

    function setMaxTxPercent(
        uint256 maxTxPercent
    ) public onlyOwner {
        _maxTxAmount =
            maxTxPercent *
            10**uint256(_decimals);
    }

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

    // to receive ETH from uniswapV2Router
    receive() external payable {}

    // ------------------------------------------------------------------------
    // Internal reflection helpers
    // ------------------------------------------------------------------------
    function _reflectFee(
        uint256 rFee,
        uint256 tFee
    ) private {
        _rTotal = _rTotal.sub(rFee);
        _tFeeTotal = _tFeeTotal.add(tFee);
    }

    function _getValues(uint256 tAmount)
        private
        view
        returns (
            uint256 rAmount,
            uint256 rTransferAmount,
            uint256 rFee,
            uint256 tTransferAmount,
            uint256 tFee,
            uint256 tLiquidity
        )
    {
        (
            tTransferAmount,
            tFee,
            tLiquidity
        ) = _getTValues(tAmount);
        (
            rAmount,
            rTransferAmount,
            rFee
        ) = _getRValues(
            tAmount,
            tFee,
            tLiquidity,
            _getRate()
        );
    }

    function _getTValues(uint256 tAmount)
        private
        view
        returns (
            uint256 tTransferAmount,
            uint256 tFee,
            uint256 tLiquidity
        )
    {
        tFee = calculateTaxFee(tAmount);
        tLiquidity = calculateLiquidityFee(
            tAmount
        );
        tTransferAmount = tAmount
            .sub(tFee)
            .sub(tLiquidity);
    }

    function _getRValues(
        uint256 tAmount,
        uint256 tFee,
        uint256 tLiquidity,
        uint256 currentRate
    )
        private
        pure
        returns (
            uint256 rAmount,
            uint256 rTransferAmount,
            uint256 rFee
        )
    {
        rAmount = tAmount.mul(currentRate);
        rFee = tFee.mul(currentRate);
        uint256 rLiquidity = tLiquidity.mul(
            currentRate
        );
        rTransferAmount = rAmount
            .sub(rFee)
            .sub(rLiquidity);
    }

    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;
        for (
            uint256 i = 0;
            i < _excluded.length;
            i++
        ) {
            if (
                _rOwned[_excluded[i]] >
                rSupply ||
                _tOwned[_excluded[i]] >
                tSupply
            ) {
                return (_rTotal, _tTotal);
            }
            rSupply = rSupply.sub(
                _rOwned[_excluded[i]]
            );
            tSupply = tSupply.sub(
                _tOwned[_excluded[i]]
            );
        }
        if (
            rSupply < _rTotal.div(_tTotal)
        ) {
            return (_rTotal, _tTotal);
        }
        return (rSupply, tSupply);
    }

    function _takeLiquidity(
        uint256 tLiquidity
    ) private {
        uint256 currentRate = _getRate();
        uint256 rLiquidity = tLiquidity.mul(
            currentRate
        );
        _rOwned[address(this)] = _rOwned[
            address(this)
        ].add(rLiquidity);
        if (_isExcluded[address(this)]) {
            _tOwned[address(this)] = _tOwned[
                address(this)
            ].add(tLiquidity);
        }
    }

    function claimTokens() public onlyOwner {
        payable(_owner).transfer(
            address(this).balance
        );
    }

    function calculateTaxFee(uint256 _amount)
        private
        view
        returns (uint256)
    {
        return _amount.mul(_taxFee).div(
            10**2
        );
    }

    function calculateLiquidityFee(
        uint256 _amount
    ) private view returns (uint256) {
        return _amount.mul(_liquidityFee).div(
            10**2
        );
    }

    function removeAllFee() private {
        if (_taxFee == 0 && _liquidityFee == 0)
            return;
        _previousTaxFee = _taxFee;
        _previousLiquidityFee = _liquidityFee;
        _taxFee = 0;
        _liquidityFee = 0;
    }

    function restoreAllFee() private {
        _taxFee = _previousTaxFee;
        _liquidityFee = _previousLiquidityFee;
    }

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

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

    // ------------------------------------------------------------------------
    // Transfer logic
    // ------------------------------------------------------------------------
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) private {
        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"
        );
        if (from != owner() && to != owner()) {
            require(
                amount <= _maxTxAmount,
                "Transfer amount exceeds the maxTxAmount."
            );
        }

        // check contract balance
        uint256 contractTokenBalance = balanceOf(
            address(this)
        );

        if (
            contractTokenBalance >= _maxTxAmount
        ) {
            contractTokenBalance = _maxTxAmount;
        }

        bool overMinTokenBalance = contractTokenBalance >=
            numTokensSellToAddToLiquidity;

        // swap & liquify
        if (
            overMinTokenBalance &&
            !inSwapAndLiquify &&
            from != uniswapV2Pair &&
            swapAndLiquifyEnabled
        ) {
            contractTokenBalance = numTokensSellToAddToLiquidity;
            swapAndLiquify(contractTokenBalance);
        }

        bool takeFee = true;
        // if excluded from fee, remove fees
        if (
            _isExcludedFromFee[from] ||
            _isExcludedFromFee[to]
        ) {
            takeFee = false;
        }

        _tokenTransfer(from, to, amount, takeFee);
    }

    function swapAndLiquify(
        uint256 contractTokenBalance
    ) private lockTheSwap {
        // split the contract balance into halves
        uint256 half = contractTokenBalance.div(
            2
        );
        uint256 otherHalf = contractTokenBalance.sub(
            half
        );

        // capture current ETH
        uint256 initialBalance = address(this)
            .balance;

        // swap tokens for ETH
        swapTokensForEth(half);

        // how much ETH did we get?
        uint256 newBalance = address(this)
            .balance
            .sub(initialBalance);

        // add liquidity
        addLiquidity(otherHalf, newBalance);

        emit SwapAndLiquify(
            half,
            newBalance,
            otherHalf
        );
    }

    function swapTokensForEth(
        uint256 tokenAmount
    ) private {
        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
        _approve(
            address(this),
            address(uniswapV2Router),
            tokenAmount
        );
        // add the liquidity
        uniswapV2Router.addLiquidityETH{
            value: ethAmount
        }(
            address(this),
            tokenAmount,
            0,
            0,
            owner(),
            block.timestamp
        );
    }

    // transfer with reflection
    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 _transferBothExcluded(
        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
        );
        _tOwned[recipient] = _tOwned[recipient]
            .add(tTransferAmount);
        _rOwned[recipient] = _rOwned[recipient]
            .add(rTransferAmount);

        _takeLiquidity(tLiquidity);
        _reflectFee(rFee, tFee);

        emit Transfer(
            sender,
            recipient,
            tTransferAmount
        );
    }
}

{
  "compilationTarget": {
    "CoinToken.sol": "CoinToken"
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": []
}