creation_sourcecode: //  Created By: PandaTool
  //  Website: https://PandaTool.org
  //  Telegram: https://t.me/PandaTool
  //  The Best Tool for Token Management
  
  // SPDX-License-Identifier: MIT
  pragma solidity ^0.8.18;
  
  
  contract Context {
  
      function _msgSender() internal view returns (address) {
          return payable(msg.sender);
      }
  
      function _msgData() internal view returns (bytes memory) {
          this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
          return msg.data;
      }
  }
  
  
  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);
              }
          }
      }
  }
  
  interface IERC20 {
      function decimals() external view returns (uint256);
  
      function symbol() external view returns (string memory);
  
      function name() external view returns (string memory);
  
      function totalSupply() external view returns (uint256);
  
      function balanceOf(address who) external view returns (uint);
  
      function transfer(
          address recipient,
          uint256 amount
      ) external returns (bool);
  
      function allowance(
          address owner,
          address spender
      ) external view returns (uint256);
  
      function approve(address _spender, uint _value) external;
  
      function transferFrom(address _from, address _to, uint _value) external ;
  
      event Transfer(address indexed from, address indexed to, uint256 value);
      event Approval(
          address indexed owner,
          address indexed spender,
          uint256 value
      );
  }
  
  
  contract PandaToken is Context, IERC20{
      using SafeMath for uint256;
      using Address for address;
  
      string private _name;
      string private _symbol;
      uint256 private _decimals;
  
      mapping(address => uint256) _balances;
      mapping(address => mapping(address => uint256)) private _allowances;
  
      address public immutable deadAddress =
          0x000000000000000000000000000000000000dEaD;
      uint256 private _totalSupply;
  
      constructor( 
          string[] memory stringParams,
          address[] memory addressParams,
          uint256[] memory numberParams,
          bool[] memory boolParams
      ) {
          require(addressParams.length==0);
          require(boolParams.length==0);
  
          address receiveAddr = tx.origin;
          _name = stringParams[0];
          _symbol = stringParams[1];
          _decimals = numberParams[0];
          _totalSupply = numberParams[1];
          _balances[receiveAddr] = _totalSupply;
          emit Transfer(address(0), receiveAddr, _totalSupply);
      }
  
      function name() public view override returns (string memory) {
          return _name;
      }
  
  
      function symbol() public view override returns (string memory) {
          return _symbol;
      }
  
      function decimals() public view override returns (uint256) {
          return _decimals;
      }
  
      function totalSupply() public view override returns (uint256) {
          return _totalSupply;
      }
  
      function owner() public view returns (address) {
          return deadAddress;
      }
  
      function balanceOf(address account) public view override returns (uint256) {
          return _balances[account];
      }
  
      function allowance(address owner1, address spender)
          public
          view
          override
          returns (uint256)
      {
          return _allowances[owner1][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 approve(address spender, uint256 amount)
          public
          override
          
      {
          _approve(_msgSender(), spender, amount);
          
      }
  
      function _approve(
          address owner1,
          address spender,
          uint256 amount
      ) private {
          require(owner1 != address(0), "ERC20: approve from the zero address");
          require(spender != address(0), "ERC20: approve to the zero address");
  
          _allowances[owner1][spender] = amount;
          emit Approval(owner1, spender, amount);
      }
  
      function getCirculatingSupply() public view returns (uint256) {
          return _totalSupply.sub(balanceOf(deadAddress));
      }
  
      //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  {
          _transfer(sender, recipient, amount);
          _approve(
              sender,
              _msgSender(),
              _allowances[sender][_msgSender()].sub(
                  amount,
                  "ERC20: transfer amount exceeds allowance"
              )
          );
          
      }
  
      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");
          return _basicTransfer(sender, recipient, amount);
      }
  
      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;
      }
  }