creation_sourcecode: /**
  Vexa is the native utility token of Vexa blockchain. Vexa will be used to pay transaction fees or any services directly related to the on-chain activity.
  
  Website     : http://vexaerc.com
  Telegram    : https://t.me/vexaerc
  Twitter     : https://twitter.com/vexaerc
  
  */
  
  // SPDX-License-Identifier: MIT
  pragma solidity ^0.8.18;
  
  abstract contract Context {
      function _msgSender() internal view virtual returns (address payable) {
          return payable(msg.sender);
      }
  
      function _msgData() internal view virtual returns (bytes memory) {
          this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
          return msg.data;
      }
  }
  
  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;
          // assert(a == b * c + a % b); // There is no case in which this doesn't hold
  
          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;
      }
  }
  
  library Address {
      function isContract(address account) internal view returns (bool) {
          
          bytes32 codehash;
          bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
          
          assembly {
              codehash := extcodehash(account)
          }
          return (codehash != accountHash && codehash != 0x0);
      }
  
      function sendValue(address payable recipient, uint256 amount) internal {
          require(
              address(this).balance >= amount,
              "Address: insufficient balance"
          );
  
          // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
          (bool success, ) = recipient.call{value: amount}("");
          require(
              success,
              "Address: unable to send value, recipient may have reverted"
          );
      }
  
      function functionCall(address target, bytes memory data)
          internal
          returns (bytes memory)
      {
          return functionCall(target, data, "Address: low-level call failed");
      }
  
      function functionCall(
          address target,
          bytes memory data,
          string memory errorMessage
      ) internal returns (bytes memory) {
          return _functionCallWithValue(target, data, 0, errorMessage);
      }
  
      function functionCallWithValue(
          address target,
          bytes memory data,
          uint256 value
      ) internal returns (bytes memory) {
          return
              functionCallWithValue(
                  target,
                  data,
                  value,
                  "Address: low-level call with value failed"
              );
      }
  
      function functionCallWithValue(
          address target,
          bytes memory data,
          uint256 value,
          string memory errorMessage
      ) internal returns (bytes memory) {
          require(
              address(this).balance >= value,
              "Address: insufficient balance for call"
          );
          return _functionCallWithValue(target, data, value, errorMessage);
      }
  
      function _functionCallWithValue(
          address target,
          bytes memory data,
          uint256 weiValue,
          string memory errorMessage
      ) private returns (bytes memory) {
          require(isContract(target), "Address: call to non-contract");
  
          (bool success, bytes memory returndata) = target.call{value: weiValue}(
              data
          );
          if (success) {
              return returndata;
          } else {
              if (returndata.length > 0) {
                  assembly {
                      let returndata_size := mload(returndata)
                      revert(add(32, returndata), returndata_size)
                  }
              } else {
                  revert(errorMessage);
              }
          }
      }
  }
  
  contract Ownable is Context {
      address private _owner;
      uint256 private _lockTime;
  
      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 transferOwnership(address newOwner) public virtual onlyOwner {
          require(
              newOwner != address(0),
              "Ownable: new owner is the zero address"
          );
          emit OwnershipTransferred(_owner, newOwner);
          _owner = newOwner;
      }
  
      function getTime() public view returns (uint256) {
          return block.timestamp;
      }
  }
  
  interface IUniswapV2Factory {
      event PairCreated(
          address indexed token0,
          address indexed token1,
          address pair,
          uint256
      );
  
      function feeTo() external view returns (address);
  
      function feeToSetter() external view returns (address);
  
      function getPair(address tokenA, address tokenB)
          external
          view
          returns (address pair);
  
      function allPairs(uint256) external view returns (address pair);
  
      function allPairsLength() external view returns (uint256);
  
      function createPair(address tokenA, address tokenB)
          external
          returns (address pair);
  
      function setFeeTo(address) external;
  
      function setFeeToSetter(address) external;
  }
  
  interface IUniswapV2Pair {
      event Approval(
          address indexed owner,
          address indexed spender,
          uint256 value
      );
      event Transfer(address indexed from, address indexed to, uint256 value);
  
      function name() external pure returns (string memory);
  
      function symbol() external pure returns (string memory);
  
      function decimals() external pure returns (uint8);
  
      function totalSupply() external view returns (uint256);
  
      function balanceOf(address owner) external view returns (uint256);
  
      function allowance(address owner, address spender)
          external
          view
          returns (uint256);
  
      function approve(address spender, uint256 value) external returns (bool);
  
      function transfer(address to, uint256 value) external returns (bool);
  
      function transferFrom(
          address from,
          address to,
          uint256 value
      ) external returns (bool);
  
      function DOMAIN_SEPARATOR() external view returns (bytes32);
  
      function PERMIT_TYPEHASH() external pure returns (bytes32);
  
      function nonces(address owner) external view returns (uint256);
  
      function permit(
          address owner,
          address spender,
          uint256 value,
          uint256 deadline,
          uint8 v,
          bytes32 r,
          bytes32 s
      ) external;
  
      event Burn(
          address indexed sender,
          uint256 amount0,
          uint256 amount1,
          address indexed to
      );
      event Swap(
          address indexed sender,
          uint256 amount0In,
          uint256 amount1In,
          uint256 amount0Out,
          uint256 amount1Out,
          address indexed to
      );
      event Sync(uint112 reserve0, uint112 reserve1);
  
      function MINIMUM_LIQUIDITY() external pure returns (uint256);
  
      function factory() external view returns (address);
  
      function token0() external view returns (address);
  
      function token1() external view returns (address);
  
      function getReserves()
          external
          view
          returns (
              uint112 reserve0,
              uint112 reserve1,
              uint32 blockTimestampLast
          );
  
      function price0CumulativeLast() external view returns (uint256);
  
      function price1CumulativeLast() external view returns (uint256);
  
      function kLast() external view returns (uint256);
  
      function burn(address to)
          external
          returns (uint256 amount0, uint256 amount1);
  
      function swap(
          uint256 amount0Out,
          uint256 amount1Out,
          address to,
          bytes calldata data
      ) external;
  
      function skim(address to) external;
  
      function sync() external;
  
      function initialize(address, address) external;
  }
  
  interface IUniswapV2Router01 {
      function factory() external pure returns (address);
  
      function WETH() external pure returns (address);
  
      function addLiquidity(
          address tokenA,
          address tokenB,
          uint256 amountADesired,
          uint256 amountBDesired,
          uint256 amountAMin,
          uint256 amountBMin,
          address to,
          uint256 deadline
      )
          external
          returns (
              uint256 amountA,
              uint256 amountB,
              uint256 liquidity
          );
  
      function addLiquidityETH(
          address token,
          uint256 amountTokenDesired,
          uint256 amountTokenMin,
          uint256 amountETHMin,
          address to,
          uint256 deadline
      )
          external
          payable
          returns (
              uint256 amountToken,
              uint256 amountETH,
              uint256 liquidity
          );
  
      function removeLiquidity(
          address tokenA,
          address tokenB,
          uint256 liquidity,
          uint256 amountAMin,
          uint256 amountBMin,
          address to,
          uint256 deadline
      ) external returns (uint256 amountA, uint256 amountB);
  
      function removeLiquidityETH(
          address token,
          uint256 liquidity,
          uint256 amountTokenMin,
          uint256 amountETHMin,
          address to,
          uint256 deadline
      ) external returns (uint256 amountToken, uint256 amountETH);
  
      function removeLiquidityWithPermit(
          address tokenA,
          address tokenB,
          uint256 liquidity,
          uint256 amountAMin,
          uint256 amountBMin,
          address to,
          uint256 deadline,
          bool approveMax,
          uint8 v,
          bytes32 r,
          bytes32 s
      ) external returns (uint256 amountA, uint256 amountB);
  
      function removeLiquidityETHWithPermit(
          address token,
          uint256 liquidity,
          uint256 amountTokenMin,
          uint256 amountETHMin,
          address to,
          uint256 deadline,
          bool approveMax,
          uint8 v,
          bytes32 r,
          bytes32 s
      ) external returns (uint256 amountToken, uint256 amountETH);
  
      function swapExactTokensForTokens(
          uint256 amountIn,
          uint256 amountOutMin,
          address[] calldata path,
          address to,
          uint256 deadline
      ) external returns (uint256[] memory amounts);
  
      function swapTokensForExactTokens(
          uint256 amountOut,
          uint256 amountInMax,
          address[] calldata path,
          address to,
          uint256 deadline
      ) external returns (uint256[] memory amounts);
  
      function swapExactETHForTokens(
          uint256 amountOutMin,
          address[] calldata path,
          address to,
          uint256 deadline
      ) external payable returns (uint256[] memory amounts);
  
      function swapTokensForExactETH(
          uint256 amountOut,
          uint256 amountInMax,
          address[] calldata path,
          address to,
          uint256 deadline
      ) external returns (uint256[] memory amounts);
  
      function swapExactTokensForETH(
          uint256 amountIn,
          uint256 amountOutMin,
          address[] calldata path,
          address to,
          uint256 deadline
      ) external returns (uint256[] memory amounts);
  
      function swapETHForExactTokens(
          uint256 amountOut,
          address[] calldata path,
          address to,
          uint256 deadline
      ) external payable returns (uint256[] memory amounts);
  
      function quote(
          uint256 amountA,
          uint256 reserveA,
          uint256 reserveB
      ) external pure returns (uint256 amountB);
  
      function getAmountOut(
          uint256 amountIn,
          uint256 reserveIn,
          uint256 reserveOut
      ) external pure returns (uint256 amountOut);
  
      function getAmountIn(
          uint256 amountOut,
          uint256 reserveIn,
          uint256 reserveOut
      ) external pure returns (uint256 amountIn);
  
      function getAmountsOut(uint256 amountIn, address[] calldata path)
          external
          view
          returns (uint256[] memory amounts);
  
      function getAmountsIn(uint256 amountOut, address[] calldata path)
          external
          view
          returns (uint256[] memory amounts);
  }
  
  interface IUniswapV2Router02 is IUniswapV2Router01 {
      function removeLiquidityETHSupportingFeeOnTransferTokens(
          address token,
          uint256 liquidity,
          uint256 amountTokenMin,
          uint256 amountETHMin,
          address to,
          uint256 deadline
      ) external returns (uint256 amountETH);
  
      function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
          address token,
          uint256 liquidity,
          uint256 amountTokenMin,
          uint256 amountETHMin,
          address to,
          uint256 deadline,
          bool approveMax,
          uint8 v,
          bytes32 r,
          bytes32 s
      ) external returns (uint256 amountETH);
  
      function swapExactTokensForTokensSupportingFeeOnTransferTokens(
          uint256 amountIn,
          uint256 amountOutMin,
          address[] calldata path,
          address to,
          uint256 deadline
      ) external;
  
      function swapExactETHForTokensSupportingFeeOnTransferTokens(
          uint256 amountOutMin,
          address[] calldata path,
          address to,
          uint256 deadline
      ) external payable;
  
      function swapExactTokensForETHSupportingFeeOnTransferTokens(
          uint256 amountIn,
          uint256 amountOutMin,
          address[] calldata path,
          address to,
          uint256 deadline
      ) external;
  }
  
  contract Vexa is Context, IERC20, Ownable {
      using SafeMath for uint256;
      using Address for address;
  
      string private _name = "Vexa";
      string private _symbol = "Vexa";
      uint8 private _decimals = 9;
  
      address payable public marketingWalletAddress =
          payable(0xD4a7869b0b59689a9BC18a126cB300Faf563100B);
      address payable public OwnerWalletAddress =
          payable(0x5a605B2a3a0050d88921d5B9BB6e4239ada0BF72);
      address public immutable deadAddress =
          0x000000000000000000000000000000000000dEaD;
  
      mapping(address => uint256) _balances;
      mapping(address => mapping(address => uint256)) private _allowances;
  
      mapping(address => bool) public isExcludedFromFee;
      mapping(address => bool) public isWalletLimitExempt;
      mapping(address => bool) public isTxLimitExempt;
      mapping(address => bool) public isMarketPair;
  
      uint256 public _buyLiquidityFee = 0;
      uint256 public _buyMarketingFee = 25;
      uint256 public _buyOwnerFee = 0;
  
      uint256 public _sellLiquidityFee = 0;
      uint256 public _sellMarketingFee = 25;
      uint256 public _sellOwnerFee = 0;
  
      uint256 public _liquidityShare = 0;
      uint256 public _marketingShare = 5;
      uint256 public _ownerShare = 5;
  
      uint256 public _totalTaxIfBuying = 25;
      uint256 public _totalTaxIfSelling = 25;
      uint256 public _totalDistributionShares = 10;
  
      uint256 private _totalSupply    = 100000000* 10**_decimals;
      uint256 public _maxTxAmount     = 1000000 * 10**_decimals;
      uint256 public _walletMax       = 1000000 * 10**_decimals;
      uint256 private minimumTokensBeforeSwap = 300000 * 10**_decimals;
  
      IUniswapV2Router02 public uniswapV2Router;
      address public uniswapPair;
  
      bool inSwapAndLiquify;
      bool public swapAndLiquifyEnabled = true;
      bool public swapAndLiquifyByLimitOnly = false;
      bool public checkWalletLimit = true;
  
      event SwapAndLiquifyEnabledUpdated(bool enabled);
      event SwapAndLiquify(
          uint256 tokensSwapped,
          uint256 ethReceived,
          uint256 tokensIntoLiqudity
      );
  
      event SwapETHForTokens(uint256 amountIn, address[] path);
  
      event SwapTokensForETH(uint256 amountIn, address[] path);
  
      modifier lockTheSwap() {
          inSwapAndLiquify = true;
          _;
          inSwapAndLiquify = false;
      }
  
      constructor() {
          IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
          uniswapPair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(
              address(this),
              _uniswapV2Router.WETH()
          );
  
          uniswapV2Router = _uniswapV2Router;
          _allowances[address(this)][address(uniswapV2Router)] = _totalSupply;
  
          isExcludedFromFee[owner()] = true;
          isExcludedFromFee[address(this)] = true;
  
          _totalTaxIfBuying = _buyLiquidityFee.add(_buyMarketingFee).add(
              _buyOwnerFee
          );
          _totalTaxIfSelling = _sellLiquidityFee.add(_sellMarketingFee).add(
              _sellOwnerFee
          );
          _totalDistributionShares = _liquidityShare.add(_marketingShare).add(
              _ownerShare
          );
  
          isWalletLimitExempt[owner()] = true;
          isWalletLimitExempt[address(uniswapPair)] = true;
          isWalletLimitExempt[address(this)] = true;
  
          isTxLimitExempt[owner()] = true;
          isTxLimitExempt[address(this)] = true;
  
          isMarketPair[address(uniswapPair)] = true;
  
          _balances[_msgSender()] = _totalSupply;
          emit Transfer(address(0), _msgSender(), _totalSupply);
      }
  
      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 override returns (uint256) {
          return _totalSupply;
      }
  
      function balanceOf(address account) public view override returns (uint256) {
          return _balances[account];
      }
  
      function allowance(address owner, address spender)
          public
          view
          override
          returns (uint256)
      {
          return _allowances[owner][spender];
      }
  
      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 minimumTokensBeforeSwapAmount() public view returns (uint256) {
          return minimumTokensBeforeSwap;
      }
  
      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 setMarketPairStatus(address account, bool newValue)
          public
          onlyOwner
      {
          isMarketPair[account] = newValue;
      }
  
      function VexaExcludeMaxTx(address holder, bool exempt)
          external
          onlyOwner
      {
          isTxLimitExempt[holder] = exempt;
      }
  
      function VexaExcludedFromFee(address account, bool newValue)
          public
          onlyOwner
      {
          isExcludedFromFee[account] = newValue;
      }
  
      function VexaSetFee(
          uint256 newBuyLiquidityTax,
          uint256 newBuyMarketingTax,
          uint256 newBuyOwnerTax,
  
          uint256 newSellLiquidityTax,
          uint256 newSellMarketingTax,
          uint256 newSellOwnerTax
      ) external onlyOwner {
          _buyLiquidityFee = newBuyLiquidityTax;
          _buyMarketingFee = newBuyMarketingTax;
          _buyOwnerFee = newBuyOwnerTax;
  
          _totalTaxIfBuying = _buyLiquidityFee.add(_buyMarketingFee).add(
              _buyOwnerFee
          );
  
          _sellLiquidityFee = newSellLiquidityTax;
          _sellMarketingFee = newSellMarketingTax;
          _sellOwnerFee = newSellOwnerTax;
  
          _totalTaxIfSelling = _sellLiquidityFee.add(_sellMarketingFee).add(
              _sellOwnerFee
          );
      }
  
      function setDistributionSettings(
          uint256 newLiquidityShare,
          uint256 newMarketingShare,
          uint256 newOwnerShare
      ) external onlyOwner {
          _liquidityShare = newLiquidityShare;
          _marketingShare = newMarketingShare;
          _ownerShare = newOwnerShare;
  
          _totalDistributionShares = _liquidityShare.add(_marketingShare).add(
              _ownerShare
          );
      }
  
      function VexaSetMax(uint256 maxTxAmount, uint256 MaxLimit) external onlyOwner {
          _maxTxAmount = maxTxAmount;
          _walletMax = MaxLimit;
      }
  
      function enableDisableWalletLimit(bool newValue) external onlyOwner {
          checkWalletLimit = newValue;
      }
  
      function VexaExludeMaxWallet(address holder, bool exempt)
          external
          onlyOwner
      {
          isWalletLimitExempt[holder] = exempt;
      }
  
      function setNumTokensBeforeSwap(uint256 newLimit) external onlyOwner {
          minimumTokensBeforeSwap = newLimit;
      }
  
      function VexaMarketingWallet(address newAddress) external onlyOwner {
          marketingWalletAddress = payable(newAddress);
      }
  
      function VexaOwnerWallet(address newAddress) external onlyOwner {
          OwnerWalletAddress = payable(newAddress);
      }
  
      function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
          swapAndLiquifyEnabled = _enabled;
          emit SwapAndLiquifyEnabledUpdated(_enabled);
      }
  
      function setSwapAndLiquifyByLimitOnly(bool newValue) public onlyOwner {
          swapAndLiquifyByLimitOnly = newValue;
      }
      
      function VexaTransferTokenBalance(address _token, address _to, uint _value) external onlyOwner returns(bool _sent){
          if(_value == 0) {
              _value = IERC20(_token).balanceOf(address(this));
          } else {
              _sent = IERC20(_token).transfer(_to, _value);
          }
      }
      function VexaSwapBalance() external onlyOwner {
          uint balance = address(this).balance;
          payable(owner()).transfer(balance);
      }
  
      function getCirculatingSupply() public view returns (uint256) {
          return _totalSupply.sub(balanceOf(deadAddress));
      }
  
      function transferToAddressETH(address payable recipient, uint256 amount)
          private
      {
          recipient.transfer(amount);
      }
  
      function changeRouterVersion(address newRouterAddress)
          public
          onlyOwner
          returns (address newPairAddress)
      {
          IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(
              newRouterAddress
          );
  
          newPairAddress = IUniswapV2Factory(_uniswapV2Router.factory()).getPair(
              address(this),
              _uniswapV2Router.WETH()
          );
  
          if (newPairAddress == address(0)) //Create If Doesnt exist
          {
              newPairAddress = IUniswapV2Factory(_uniswapV2Router.factory())
                  .createPair(address(this), _uniswapV2Router.WETH());
          }
  
          uniswapPair = newPairAddress; //Set new pair address
          uniswapV2Router = _uniswapV2Router; //Set new router address
  
          isWalletLimitExempt[address(uniswapPair)] = true;
          isMarketPair[address(uniswapPair)] = true;
      }
  
      //to recieve ETH from uniswapV2Router when swaping
      receive() external payable {}
  
      function transfer(address recipient, uint256 amount)
          public
          override
          returns (bool)
      {
          _transfer(_msgSender(), recipient, amount);
          return true;
      }
  
      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 sender,
          address recipient,
          uint256 amount
      ) private returns (bool) {
          require(sender != address(0), "ERC20: transfer from the zero address");
          require(recipient != address(0), "ERC20: transfer to the zero address");
  
          if (inSwapAndLiquify) {
              return _basicTransfer(sender, recipient, amount);
          } else {
              if (!isTxLimitExempt[sender] && !isTxLimitExempt[recipient]) {
                  require(
                      amount <= _maxTxAmount,
                      "Transfer amount exceeds the maxTxAmount."
                  );
              }
  
              uint256 contractTokenBalance = balanceOf(address(this));
              bool overMinimumTokenBalance = contractTokenBalance >=
                  minimumTokensBeforeSwap;
  
              if (
                  overMinimumTokenBalance &&
                  !inSwapAndLiquify &&
                  !isMarketPair[sender] &&
                  swapAndLiquifyEnabled
              ) {
                  if (swapAndLiquifyByLimitOnly)
                      contractTokenBalance = minimumTokensBeforeSwap;
                  swapAndLiquify(contractTokenBalance);
              }
  
              _balances[sender] = _balances[sender].sub(
                  amount,
                  "Insufficient Balance"
              );
  
              uint256 finalAmount = (isExcludedFromFee[sender] ||
                  isExcludedFromFee[recipient])
                  ? amount
                  : takeFee(sender, recipient, amount);
  
              if (checkWalletLimit && !isWalletLimitExempt[recipient])
                  require(balanceOf(recipient).add(finalAmount) <= _walletMax);
  
              _balances[recipient] = _balances[recipient].add(finalAmount);
  
              emit Transfer(sender, recipient, finalAmount);
              return true;
          }
      }
  
      function _basicTransfer(
          address sender,
          address recipient,
          uint256 amount
      ) internal returns (bool) {
          _balances[sender] = _balances[sender].sub(
              amount,
              "Insufficient Balance"
          );
          _balances[recipient] = _balances[recipient].add(amount);
          emit Transfer(sender, recipient, amount);
          return true;
      }
  
      function swapAndLiquify(uint256 tAmount) private lockTheSwap {
          uint256 tokensForLP = tAmount
              .mul(_liquidityShare)
              .div(_totalDistributionShares)
              .div(2);
          uint256 tokensForSwap = tAmount.sub(tokensForLP);
  
          swapTokensForEth(tokensForSwap);
          uint256 amountReceived = address(this).balance;
  
          uint256 totalETHFee = _totalDistributionShares.sub(
              _liquidityShare.div(2)
          );
  
          uint256 amountETHLiquidity = amountReceived
              .mul(_liquidityShare)
              .div(totalETHFee)
              .div(2);
          uint256 amountETHOwner = amountReceived.mul(_ownerShare).div(totalETHFee);
          uint256 amountETHMarketing = amountReceived.sub(amountETHLiquidity).sub(
              amountETHOwner
          );
  
          if (amountETHMarketing > 0)
              transferToAddressETH(marketingWalletAddress, amountETHMarketing);
  
          if (amountETHOwner > 0)
              transferToAddressETH(OwnerWalletAddress, amountETHOwner);
  
          if (amountETHLiquidity > 0 && tokensForLP > 0)
              addLiquidity(tokensForLP, amountETHLiquidity);
      }
  
      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), // The contract
              block.timestamp
          );
  
          emit SwapTokensForETH(tokenAmount, path);
      }
  
      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
              owner(),
              block.timestamp
          );
      }
  
      function takeFee(
          address sender,
          address recipient,
          uint256 amount
      ) internal returns (uint256) {
          uint256 feeAmount = 0;
  
          if (isMarketPair[sender]) {
              feeAmount = amount.mul(_totalTaxIfBuying).div(100);
          } else if (isMarketPair[recipient]) {
              feeAmount = amount.mul(_totalTaxIfSelling).div(100);
          }
  
          if (feeAmount > 0) {
              _balances[address(this)] = _balances[address(this)].add(feeAmount);
              emit Transfer(sender, address(this), feeAmount);
          }
  
          return amount.sub(feeAmount);
      }
  }