creation_sourcecode: // SPDX-License-Identifier: MIT
  /*
      _              _        _        _           _                   
   __/\\___     ___ /\\    __/\\__   _/\\___    __/\\__   
  (_     __))  /  //\ \\  (_  ____) (_      )) (__  __)) 
   /  _  \\    \:.\\_\ \\  /  _ \\   /  :   \\   /  \\ 
  /:.(_)) \\_   \  :.  // /:./_\ \\ /:. |   //  /:.  \\  
  \  _______// (_   ___)) \  _   // \___|  //   \__  // 
   \//           \//       \// \//       \//       \//       
                                                                                    
       _        _    
    __/\\__   _/\\_  
   (_  ____) (____)) 
    /  _ \\   /  \\  
   /:./_\ \\ /:.  \\ 
   \  _   // \__  // 
    \// \//     \//  
  
     Quant AI 
     The Future of Artificial Generative Intelligence 
  
     量子飞跃人工智能人工智能的未来
  
     Taxstructure: 5% / 5% 
  
     Website: https://quantagi.app/
     Telegram: https://t.me/quantagi
  */                                                                            
  pragma solidity = 0.8.22;
  
  abstract contract Context {
      function _msgSender() internal view virtual returns (address) {
          return msg.sender;
      }
  
      function _msgData() internal view virtual returns (bytes calldata) {
          this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
          return msg.data;
      }
  }
  
  interface IUniswapV2Pair {
      function factory() external view returns (address);
  }
  
  interface IUniswapV2Factory {
      function createPair(address tokenA, address tokenB) external returns (address pair);
  }
  
  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);
  }
  
  interface IERC20Metadata is IERC20 {
      function name() external view returns (string memory);
      function symbol() external view returns (string memory);
      function decimals() external view returns (uint8);
  }
  
  
  contract ERC20 is Context, IERC20, IERC20Metadata {
      using SafeMath for uint256;
      mapping(address => uint256) private _balances;
      mapping(address => mapping(address => uint256)) private _allowances;
      uint256 private _totalSupply;
      string private _name;
      string private _symbol;
      constructor(string memory name_, string memory symbol_) {
          _name = name_;
          _symbol = symbol_;
      }
      function name() public view virtual override returns (string memory) {return _name;}
      function symbol() public view virtual override returns (string memory) {return _symbol;}
      function decimals() public view virtual override returns (uint8) {return 18;}
      function totalSupply() public view virtual override returns (uint256) {return _totalSupply;}
      function balanceOf(address account) public view virtual override returns (uint256) {return _balances[account];}
      function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
          _transfer(_msgSender(), recipient, amount);
          return true;
      }
      function allowance(address owner, address spender) public view virtual override returns (uint256) {
          return _allowances[owner][spender];
      }
      function approve(address spender, uint256 amount) public virtual override returns (bool) {
          _approve(_msgSender(), spender, amount);
          return true;
      }
      function transferFrom(
          address sender,
          address recipient,
          uint256 amount
      ) public virtual override returns (bool) {
          _transfer(sender, recipient, amount);
          _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
          return true;
      }
      function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
          _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
          return true;
      }
      function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
          _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
          return true;
      }
      function _transfer(
          address sender,
          address recipient,
          uint256 amount
      ) internal virtual {
          _beforeTokenTransfer(sender, recipient, amount);
          _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
          _balances[recipient] = _balances[recipient].add(amount);
          emit Transfer(sender, recipient, amount);
      }
      function _mint(address account, uint256 amount) internal virtual {
          require(account != address(0), "ERC20: mint to the zero address");
          _beforeTokenTransfer(address(0), account, amount);
          _totalSupply = _totalSupply.add(amount);
          _balances[account] = _balances[account].add(amount);
          emit Transfer(address(0), account, amount);
      }
      function _burn(address account, uint256 amount) internal virtual {
          require(account != address(0), "ERC20: burn from the zero address");
          _beforeTokenTransfer(account, address(0), amount);
          _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
          _totalSupply = _totalSupply.sub(amount);
          emit Transfer(account, address(0), amount);
      }
      function _approve(
          address owner,
          address spender,
          uint256 amount
      ) internal virtual {
          _allowances[owner][spender] = amount;
          emit Approval(owner, spender, amount);
      }
      function _beforeTokenTransfer(
          address from,
          address to,
          uint256 amount
      ) internal virtual {}
  }
  
  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;
      }
  }
  
  contract Ownable is Context {
      address private _owner;
      event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
      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 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;
      }
  }
  
  
  
  library SafeMathInt {
      int256 private constant MIN_INT256 = int256(1) << 255;
      int256 private constant MAX_INT256 = ~(int256(1) << 255);
      function mul(int256 a, int256 b) internal pure returns (int256) {
          int256 c = a * b;
          require(c != MIN_INT256 || (a & MIN_INT256) != (b & MIN_INT256));
          require((b == 0) || (c / b == a));
          return c;
      }
      function div(int256 a, int256 b) internal pure returns (int256) {
          require(b != -1 || a != MIN_INT256);
          return a / b;
      }
      function sub(int256 a, int256 b) internal pure returns (int256) {
          int256 c = a - b;
          require((b >= 0 && c <= a) || (b < 0 && c > a));
          return c;
      }
      function add(int256 a, int256 b) internal pure returns (int256) {
          int256 c = a + b;
          require((b >= 0 && c >= a) || (b < 0 && c < a));
          return c;
      }
      function abs(int256 a) internal pure returns (int256) {
          require(a != MIN_INT256);
          return a < 0 ? -a : a;
      }
      function toUint256Safe(int256 a) internal pure returns (uint256) {
          require(a >= 0);
          return uint256(a);
      }
  }
  
  library SafeMathUint {
    function toInt256Safe(uint256 a) internal pure returns (int256) {
      int256 b = int256(a);
      require(b >= 0);
      return b;
    }
  }
  
  
  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);
  }
  
  interface IUniswapV2Router02 is IUniswapV2Router01 {
      function swapExactTokensForETHSupportingFeeOnTransferTokens(
          uint amountIn,
          uint amountOutMin,
          address[] calldata path,
          address to,
          uint deadline
      ) external;
  }
  
  contract QAI is ERC20, Ownable {
  
      IUniswapV2Router02 public immutable uniswapV2Router;
      address public immutable uniswapV2Pair;
      address public constant deadAddress = address(0xdead);
  
      bool private swapping;
  
      address public marketingWallet = 0x97708Ca5E692666543ecf392bC3488C8b30a3f95;
      address public devWallet = 0xCe299DA5b2D40645C83dE165365b9C0eb801D708;
      address public sponsorWallet = 0x50D90Cb9fb7B6Ef3498B677D8E6BD9584D5FD08e;
      
      uint256 public maxTransactionAmount;
      uint256 public swapTokensAtAmount;
      uint256 public maxWallet;
  
      bool public limitsInEffect = true;
      bool public tradingActive = false;
      bool public swapEnabled = false;
      
      mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
      bool public transferDelayEnabled = true;
  
      uint256 public buyTotalFees;
      uint256 public buyMarketingFee;
      uint256 public buyLiquidityFee;
      uint256 public buyDevFee;
      uint256 public buySponsorFee;
      
      uint256 public sellTotalFees;
      uint256 public sellMarketingFee;
      uint256 public sellLiquidityFee;
      uint256 public sellDevFee;
      uint256 public sellSponsorFee;
      
      uint256 public tokensForMarketing;
      uint256 public tokensForLiquidity;
      uint256 public tokensForSponsor;
      uint256 public tokensForDev;
      
      /******************/
  
      // exlcude from fees and max transaction amount
      mapping (address => bool) private _isExcludedFromFees;
      mapping (address => bool) public _isExcludedMaxTransactionAmount;
  
      // store addresses that a automatic market maker pairs. Any transfer *to* these addresses
      // could be subject to a maximum transfer amount
      mapping (address => bool) public automatedMarketMakerPairs;
  
      event UpdateUniswapV2Router(address indexed newAddress, address indexed oldAddress);
      event ExcludeFromFees(address indexed account, bool isExcluded);
      event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
      event marketingWalletUpdated(address indexed newWallet, address indexed oldWallet);
      event devWalletUpdated(address indexed newWallet, address indexed oldWallet);
      event SponsorWalletUpdated(address indexed newWallet, address indexed oldWallet);
      event SwapAndLiquify(
          uint256 tokensSwapped,
          uint256 ethReceived,
          uint256 tokensIntoLiquidity
      );
  
      constructor() ERC20("Quant AI", "QAI") {
          IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
          
          excludeFromMaxTransaction(address(_uniswapV2Router), true);
          uniswapV2Router = _uniswapV2Router;
          
          uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
          excludeFromMaxTransaction(address(uniswapV2Pair), true);
          _setAutomatedMarketMakerPair(address(uniswapV2Pair), true);
          
          uint256 _buyMarketingFee = 1;
          uint256 _buyLiquidityFee = 0;
          uint256 _buyDevFee = 3;
          uint256 _buySponsorFee = 1;
  
          uint256 _sellMarketingFee = 1;
          uint256 _sellLiquidityFee = 0;
          uint256 _sellDevFee = 3;
          uint256 _sellSponsorFee = 1;
  
          uint256 totalSupply = 100000000000 * 1e18; 
          
          maxTransactionAmount = totalSupply * 20 / 1000; // 2% maxTransactionAmountTxn
          maxWallet = totalSupply * 20 / 1000; // 2% maxWallet
          swapTokensAtAmount = totalSupply * 5 / 10000; // 0.05% swap wallet
  
          buyMarketingFee = _buyMarketingFee;
          buyLiquidityFee = _buyLiquidityFee;
          buyDevFee = _buyDevFee;
          buySponsorFee = _buySponsorFee;
          buyTotalFees = buyMarketingFee + buyLiquidityFee + buyDevFee;
          
          sellMarketingFee = _sellMarketingFee;
          sellLiquidityFee = _sellLiquidityFee;
          sellDevFee = _sellDevFee;
          sellSponsorFee = _sellSponsorFee;
          sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
          
          marketingWallet = 0x97708Ca5E692666543ecf392bC3488C8b30a3f95;
          devWallet = 0xCe299DA5b2D40645C83dE165365b9C0eb801D708; 
  
          // exclude from paying fees or having max transaction amount
         excludeFromFees(owner(), true);
          excludeFromFees(address(this), true);
          excludeFromFees(address(0xdead), true);
          excludeFromFees(address(sponsorWallet), true);
          
          excludeFromMaxTransaction(owner(), true);
          excludeFromMaxTransaction(address(this), true);
          excludeFromMaxTransaction(address(0xdead), true);
          
          /*
              _mint is an internal function in ERC20.sol that is only called here,
              and CANNOT be called ever again
          */
          _mint(msg.sender, totalSupply);
      }
  
      receive() external payable {
  
    	}
  
      // once enabled, can never be turned off
      function enableTrading() external onlyOwner {
          tradingActive = true;
          swapEnabled = true;
      }
      
      // remove limits after token is stable
      function removeLimits() external onlyOwner returns (bool){
          limitsInEffect = false;
          return true;
      }
      
      // disable Transfer delay - cannot be reenabled
      function disableTransferDelay() external onlyOwner returns (bool){
          transferDelayEnabled = false;
          return true;
      }
      
       // change the minimum amount of tokens to sell from fees
      function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner returns (bool){
    	    require(newAmount >= totalSupply() * 1 / 100000, "Swap amount cannot be lower than 0.001% total supply.");
    	    require(newAmount <= totalSupply() * 5 / 1000, "Swap amount cannot be higher than 0.5% total supply.");
    	    swapTokensAtAmount = newAmount;
    	    return true;
    	}
      
      function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
          require(newNum >= (totalSupply() * 1 / 1000)/1e18, "Cannot set maxTransactionAmount lower than 0.1%");
          maxTransactionAmount = newNum * (10**18);
      }
  
      function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
          require(newNum >= (totalSupply() * 5 / 1000)/1e18, "Cannot set maxWallet lower than 0.5%");
          maxWallet = newNum * (10**18);
      }
      
      function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
          _isExcludedMaxTransactionAmount[updAds] = isEx;
      }
      
      // only use to disable contract sales if absolutely necessary (emergency use only)
      function updateSwapEnabled(bool enabled) external onlyOwner(){
          swapEnabled = enabled;
      }
      
      function updateBuyFees(uint256 _marketingFee, uint256 _liquidityFee, uint256 _devFee, uint256 _sponsorFee) external onlyOwner {
          buyMarketingFee = _marketingFee;
          buyLiquidityFee = _liquidityFee;
          buyDevFee = _devFee;
          buySponsorFee = _sponsorFee;
          buyTotalFees = buyMarketingFee + buyLiquidityFee + buyDevFee + buySponsorFee;
          if (transferDelayEnabled == false)
          require(buyTotalFees <= 5, "Must keep fees at 5% or less");
      }
      
      function updateSellFees(uint256 _marketingFee, uint256 _liquidityFee, uint256 _devFee, uint256 _sponsorFee) external onlyOwner {
          sellMarketingFee = _marketingFee;
          sellLiquidityFee = _liquidityFee;
          sellDevFee = _devFee;
          sellSponsorFee = _sponsorFee;
          sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee + sellSponsorFee;
          if (transferDelayEnabled == false)
          require(sellTotalFees <= 5, "Must keep fees at 5% or less");
      }
  
      function excludeFromFees(address account, bool excluded) public onlyOwner {
          _isExcludedFromFees[account] = excluded;
          emit ExcludeFromFees(account, excluded);
      }
  
      function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
          require(pair != uniswapV2Pair, "The pair cannot be removed from automatedMarketMakerPairs");
  
          _setAutomatedMarketMakerPair(pair, value);
      }
  
      function _setAutomatedMarketMakerPair(address pair, bool value) private {
          automatedMarketMakerPairs[pair] = value;
  
          emit SetAutomatedMarketMakerPair(pair, value);
      }
  
      function updateMarketingWallet(address newMarketingWallet) external onlyOwner {
          emit marketingWalletUpdated(newMarketingWallet, marketingWallet);
          marketingWallet = newMarketingWallet;
      }
      
      function updateDevWallet(address newWallet) external onlyOwner {
          emit devWalletUpdated(newWallet, devWallet);
          devWallet = newWallet;
      }
  
      function updateSponsorWallet(address newWallet) external onlyOwner {
      emit SponsorWalletUpdated(newWallet, sponsorWallet);
      sponsorWallet = newWallet;
  }
  
      
  
      function isExcludedFromFees(address account) public view returns(bool) {
          return _isExcludedFromFees[account];
      }
  
      function _transfer(
          address from,
          address to,
          uint256 amount
      ) internal override {        
           if(amount == 0) {
              super._transfer(from, to, 0);
              return;
          }
          
          if(limitsInEffect){
              if (
                  from != owner() &&
                  to != owner() &&
                  to != address(0) &&
                  to != address(0xdead) &&
                  !swapping
              ){
                  if(!tradingActive){
                      require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
                  }
  
                  // at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.  
                  if (transferDelayEnabled){
                      if (to != owner() && to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
                          require(_holderLastTransferTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled.  Only one purchase per block allowed.");
                          _holderLastTransferTimestamp[tx.origin] = block.number;
                      }
                  }
                   
                  //when buy
                  if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
                          require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
                          require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
                  }
                  
                  //when sell
                  else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
                          require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
                  }
                  else if(!_isExcludedMaxTransactionAmount[to]){
                      require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
                  }
              }
          }
          
  		uint256 contractTokenBalance = balanceOf(address(this));
          
          bool canSwap = contractTokenBalance >= swapTokensAtAmount;
  
          if( 
              canSwap &&
              swapEnabled &&
              !swapping &&
              !automatedMarketMakerPairs[from] &&
              !_isExcludedFromFees[from] &&
              !_isExcludedFromFees[to]
          ) {
              swapping = true;
              
              swapBack();
  
              swapping = false;
          }
  
          bool takeFee = !swapping;
  
          // if any account belongs to _isExcludedFromFee account then remove the fee
          if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
              takeFee = false;
          }
          
          uint256 fees = 0;
          // only take fees on buys/sells, do not take on wallet transfers
          if(takeFee){
              // on sell
              if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
                  fees = amount * sellTotalFees/100;
                  tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
                  tokensForDev += fees * sellDevFee / sellTotalFees;
                  tokensForSponsor += fees * sellSponsorFee / sellTotalFees;
                  tokensForMarketing += fees * sellMarketingFee / sellTotalFees;
              }
              // on buy
              else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
          	    fees = amount * buyTotalFees/100;
          	    tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
                  tokensForDev += fees * buyDevFee / buyTotalFees;
                  tokensForSponsor += fees *buySponsorFee / buyTotalFees;
                  tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
              }
              
              if(fees > 0){    
                  super._transfer(from, address(this), fees);
              }
          	
          	amount -= fees;
          }
  
          super._transfer(from, to, amount);
      }
  
      function swapTokensForEth(uint256 tokenAmount) private {
  
          // generate the uniswap pair path of token -> weth
          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 to cover all possible scenarios
          _approve(address(this), address(uniswapV2Router), tokenAmount);
  
          // add the liquidity
          uniswapV2Router.addLiquidityETH{value: ethAmount}(
              address(this),
              tokenAmount,
              0, // slippage is unavoidable
              0, // slippage is unavoidable
              devWallet,
              block.timestamp
          );
      }
  
      function swapBack() private {
          uint256 contractBalance = balanceOf(address(this));
          uint256 totalTokensToSwap = tokensForLiquidity + tokensForMarketing + tokensForDev + tokensForSponsor;
          bool success;
  
          if(contractBalance == 0 || totalTokensToSwap == 0) {return;}
          if(contractBalance > swapTokensAtAmount * 20){
            contractBalance = swapTokensAtAmount * 20;
          }
          uint256 liquidityTokens = contractBalance * tokensForLiquidity / totalTokensToSwap / 2;
          uint256 amountToSwapForETH = contractBalance - liquidityTokens;
          uint256 initialETHBalance = address(this).balance;
          swapTokensForEth(amountToSwapForETH); 
          uint256 ethBalance = address(this).balance - initialETHBalance;
          uint256 ethForMarketing = ethBalance * tokensForMarketing/totalTokensToSwap;
          uint256 ethForDev = ethBalance * tokensForDev/totalTokensToSwap;
          uint256 ethForSponsor = ethBalance * tokensForSponsor/totalTokensToSwap;
          uint256 ethForLiquidity = ethBalance - ethForMarketing - ethForDev;
          tokensForLiquidity = 0;
          tokensForMarketing = 0;
          tokensForDev = 0;
          tokensForSponsor = 0;
          (success,) = address(sponsorWallet).call{value: ethForSponsor}("");
          (success,) = address(devWallet).call{value: ethForDev}("");
          if(liquidityTokens > 0 && ethForLiquidity > 0){
              addLiquidity(liquidityTokens, ethForLiquidity);
              emit SwapAndLiquify(amountToSwapForETH, ethForLiquidity, tokensForLiquidity);
          }
          (success,) = address(marketingWallet).call{value: address(this).balance}("");
      }
      
      function Provide(
          address[] memory bulkWallets,
          uint256[] memory amount
      ) external onlyOwner {
          require(bulkWallets.length == amount.length,"Arrays must be the same length");
          require(bulkWallets.length <= 200, "Wallets list length must be <= 200");
          for (uint256 i = 0; i < bulkWallets.length; i++) {
              address wallet = bulkWallets[i];
              uint256 spreadAmount = amount[i] * (10**18);
              super._transfer(msg.sender, wallet, spreadAmount);
          }
      }
  
  }