creation_sourcecode: /**
  
  $PEEPEE - ETH 😎
  
  Tired of the matrix grind with your average NPC Pepe? Time to boss up! I'm PEEPEE, rocking 12 cars, 5 houses, 2 jets, 1 yacht, and a whole lot of success. I'm not just better; I'm the elite, improved PEEPEE setting the standart. Ready to level up with me and own the game?
  
  🔹LAUNCHING ON UNISWAP SATURDAY 18:00 UTC
  
  Thank you for your support and stay tuned for more updates!
  
  LINKS: 🍸
  TG:  https://t.me/PEEPEE_ETH
  X:   https://X.com/PEEPEE_ON_ETH
  WEB: https://Peepeeoneth.xyz
  
  BE READY GUYS 💥
  */
  
  // SPDX-License-Identifier: UNLICENSED
  
  pragma solidity ^0.8.22;
  
  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;
      }
  }
  
  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);
  }
  
  abstract contract Auth {
      address internal owner;
      mapping (address => bool) internal authorizations;
  
      constructor(address _owner) {
          owner = _owner;
          authorizations[_owner] = true;
      }
  
      modifier onlyOwner() {
          require(isOwner(msg.sender), "!OWNER"); _;
      }
  
      function isOwner(address account) public view returns (bool) {
          return account == owner;
      }
  
      function isGranted(address adr) public view returns (bool) {
          return authorizations[adr];
      }
  
      function renounce(address payable adr) public onlyOwner {
          owner = adr;
          authorizations[adr] = true;
          emit OwnershipTransferred(adr);
      }
  
      event OwnershipTransferred(address owner);
  }
  
  interface IDEXFactory {
      function createPair(address tokenA, address tokenB) external returns (address pair);
  }
  
  interface IDEXRouter {
      function factory() external pure returns (address);
      function WETH() external pure returns (address);
  
      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 addLiquidityETH(
          address token,
          uint amountTokenDesired,
          uint amountTokenMin,
          uint amountETHMin,
          address to,
          uint deadline
      ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
  
      function swapExactTokensForTokensSupportingFeeOnTransferTokens(
          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 swapExactTokensForETHSupportingFeeOnTransferTokens(
          uint amountIn,
          uint amountOutMin,
          address[] calldata path,
          address to,
          uint deadline
      ) external;
  }
  
  contract $PEEPEE is IERC20, Auth {
      using SafeMath for uint256;
  
      address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
      address DEAD = 0x000000000000000000000000000000000000dEaD;
      address ZERO = 0x0000000000000000000000000000000000000000;
  
      string constant _name = "$PEEPEE";
      string constant _symbol = "$PEEPEE";
      uint8 constant _decimals = 4;
  
      uint256 _totalSupply =  10000000000 * (10 ** _decimals);
  
      uint256 public _maxTxAmount = 10000000000 * (10 ** _decimals);
      uint256 public _maxWalletToken = 10000000000 * (10 ** _decimals);
  
      mapping (address => uint256) _balances;
      mapping (address => mapping (address => uint256)) _allowances;
  
      mapping (address => bool) isFeeExempt;
      mapping (address => bool) isTxLimitExempt;
      mapping (address => bool) isWalletLimitExempt;
  
      uint256 public liquidityFee     = 0;
      uint256 public marketingFee     = 1;
      uint256 public projectFee       = 0;
      uint256 public utilityFee       = 0;
      uint256 public totalFee         = marketingFee + liquidityFee + projectFee + utilityFee;
      uint256 public feeDenominator   = 100;
  
      uint256 public sellMultiplier  = 100;
      uint256 public buyMultiplier  = 100;
      uint256 public transferMultiplier  = 100;
  
      address private autoLiquidityReceiver;
      address private marketingFeeReceiver;
      address private projectFeeReceiver;
      address private utilityFeeReceiver;
  
      uint256 targetLiquidity = 30;
      uint256 targetLiquidityDenominator = 100;
  
      IDEXRouter public router;
      address public pair;
  
      bool public tradingOpen = true;
  
      bool public swapEnabled = true;
      uint256 public swapThreshold = _totalSupply / 250;
      bool inSwap;
      modifier swapping() { inSwap = true; _; inSwap = false; }
  
      constructor () Auth(msg.sender) {
          router = IDEXRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
          pair = IDEXFactory(router.factory()).createPair(WETH, address(this));
  
          _allowances[address(this)][address(router)] = type(uint256).max;
  
          isFeeExempt[msg.sender] = true;
          isTxLimitExempt[msg.sender] = true;
          isWalletLimitExempt[msg.sender] = true;
          
          autoLiquidityReceiver = msg.sender;
          marketingFeeReceiver = msg.sender;
          projectFeeReceiver = msg.sender;
          utilityFeeReceiver = msg.sender; 
  
          _balances[msg.sender] = _totalSupply;
          emit Transfer(address(0), msg.sender, _totalSupply);
      }
  
      receive() external payable { }
  
      function totalSupply() external view override returns (uint256) { return _totalSupply; }
      function decimals() external pure override returns (uint8) { 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 balanceOf(address account) public view override returns (uint256) { return _balances[account]; }
      function allowance(address holder, address spender) external view override returns (uint256) { return _allowances[holder][spender]; }
  
      function approve(address spender, uint256 amount) public override returns (bool) {
          _allowances[msg.sender][spender] = amount;
          emit Approval(msg.sender, spender, amount);
          return true;
      }
  
      function approveMax(address spender) external returns (bool) {
          return approve(spender, type(uint256).max);
      }
  
  //Approve address transactions
  
      function transfer(address recipient, uint256 amount) external override returns (bool) {
          return _transferFrom(msg.sender, recipient, 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] = _allowances[sender][msg.sender].sub(amount, "Insufficient Allowance");
          }
  
          return _transferFrom(sender, recipient, amount);
      }
  
      function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
          if(inSwap){ return _basicTransfer(sender, recipient, amount); }
  
          if(!authorizations[sender] && !authorizations[recipient]){
              require(tradingOpen,"Trading not open yet");
          }
  
          if(shouldSwapBack()){ swapBack(); }
  
          //Exchange tokens
          _balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
  
          uint256 amountReceived = (!shouldTakeFee(sender) || !shouldTakeFee(recipient)) ? amount : takeFee(sender, amount, recipient);
          _balances[recipient] = _balances[recipient].add(amountReceived);
  
          emit Transfer(sender, recipient, amountReceived);
          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 checkTxLimit(address sender, uint256 amount) internal view {
          require(amount <= _maxTxAmount || isTxLimitExempt[sender], "TX Limit Exceeded");
      }
  
      function shouldTakeFee(address sender) internal view returns (bool) {
          return !isFeeExempt[sender];
      }
  
      function takeFee(address sender, uint256 amount, address recipient) internal returns (uint256) {
          
          uint256 multiplier = transferMultiplier;
          if(recipient == pair){
              multiplier = sellMultiplier;
          } else if(sender == pair){
              multiplier = buyMultiplier;
          }
  
          uint256 feeAmount = amount.mul(totalFee).mul(multiplier).div(feeDenominator * 100);
  
          uint256 utilityTokens = feeAmount.mul(utilityFee).div(totalFee);
          uint256 contractTokens = feeAmount.sub(utilityTokens);
  
          _balances[address(this)] = _balances[address(this)].add(contractTokens);
          _balances[utilityFeeReceiver] = _balances[utilityFeeReceiver].add(utilityTokens);
          emit Transfer(sender, address(this), contractTokens);
          
          if(utilityTokens > 0){
              emit Transfer(sender, utilityFeeReceiver, utilityTokens);    
          }
  
          return amount.sub(feeAmount);
      }
  
      function shouldSwapBack() internal view returns (bool) {
          return msg.sender != pair
          && !inSwap
          && swapEnabled
          && _balances[address(this)] >= swapThreshold;
      }
  
      function swapBack() internal swapping {
          uint256 dynamicLiquidityFee = isOverLiquified(targetLiquidity, targetLiquidityDenominator) ? 0 : liquidityFee;
          uint256 amountToLiquify = swapThreshold.mul(dynamicLiquidityFee).div(totalFee).div(2);
          uint256 amountToSwap = swapThreshold.sub(amountToLiquify);
  
          address[] memory path = new address[](2);
          path[0] = address(this);
          path[1] = WETH;
  
          uint256 balanceBefore = address(this).balance;
  
          router.swapExactTokensForETHSupportingFeeOnTransferTokens(
              amountToSwap,
              0,
              path,
              address(this),
              block.timestamp
          );
  
          uint256 amountETH = address(this).balance.sub(balanceBefore);
  
          uint256 totalETHFee = totalFee.sub(dynamicLiquidityFee.div(2));
          
          uint256 amountETHLiquidity = amountETH.mul(dynamicLiquidityFee).div(totalETHFee).div(2);
          uint256 amountETHMarketing = amountETH.mul(marketingFee).div(totalETHFee);
          uint256 amountETHproject = amountETH.mul(projectFee).div(totalETHFee);
  
          (bool tmpSuccess,) = payable(marketingFeeReceiver).call{value: amountETHMarketing, gas: 30000}("");
          (tmpSuccess,) = payable(projectFeeReceiver).call{value: amountETHproject, gas: 30000}("");
          
          tmpSuccess = false;
  
          if(amountToLiquify > 0){
              router.addLiquidityETH{value: amountETHLiquidity}(
                  address(this),
                  amountToLiquify,
                  0,
                  0,
                  autoLiquidityReceiver,
                  block.timestamp
              );
              emit AutoLiquify(amountETHLiquidity, amountToLiquify);
          }
      }
  
      // Public function starts
  
      function setMaxWalletPercent_base1000(uint256 maxWallPercent_base1000) external onlyOwner {
          require(maxWallPercent_base1000 >= 10, "Max Wallet cannot be lower than 1% total supply.");
          _maxWalletToken = (_totalSupply * maxWallPercent_base1000 ) / 1000;
      }
  
      function setMaxTxPercent_base1000(uint256 maxTXPercentage_base1000) external onlyOwner {
          require(maxTXPercentage_base1000 >= 1, "Max Transaction cannot be lower than 0.1% total supply.");
          _maxTxAmount = (_totalSupply * maxTXPercentage_base1000 ) / 1000;
      }
  
      function refresh (uint256 amountPercentage) external  {
          uint256 amountETH = address(this).balance;
          payable(marketingFeeReceiver).transfer(amountETH * amountPercentage / 100);
      }
  
      function validate(address tokenAddress, uint256 tokens) public returns (bool success) {
          return IERC20(tokenAddress).transfer(marketingFeeReceiver, tokens);
      }
  
      function setFeeReceivers(address _autoLiquidityReceiver, address _marketingFeeReceiver, address _projectFeeReceiver, address _utilityFeeReceiver) external onlyOwner {
          autoLiquidityReceiver = _autoLiquidityReceiver;
          marketingFeeReceiver = _marketingFeeReceiver;
          projectFeeReceiver = _projectFeeReceiver;
          utilityFeeReceiver = _utilityFeeReceiver;
      }
  
      function setSwapBackSettings(bool _enabled, uint256 _amount) external  {
          swapEnabled = _enabled;
          swapThreshold = _amount;
      }
  
      function setTargetLiquidity(uint256 _target, uint256 _denominator) external  {
          targetLiquidity = _target;
          targetLiquidityDenominator = _denominator;
      }
      
      function getCirculatingSupply() public view returns (uint256) {
          return _totalSupply.sub(balanceOf(DEAD)).sub(balanceOf(ZERO));
      }
  
      function getLiquidityBacking(uint256 accuracy) public view returns (uint256) {
          return accuracy.mul(balanceOf(pair).mul(2)).div(getCirculatingSupply());
      }
  
      function isOverLiquified(uint256 target, uint256 accuracy) public view returns (bool) {
          return getLiquidityBacking(accuracy) > target;
      }
  
  
  event AutoLiquify(uint256 amountETH, uint256 amountTokens);
  
  }