creation_sourcecode: /*
  Yo, devs in the house! Feeling bored outta my mind scrolling through the same old rug pulls? 
  Ain't nobody got time for that! It's time to shake things up, to make a statement in the crypto cosmos. 
  Enter stage left: PEPE PRINTOOOR – the antidote to your crypto blues, the spark that ignites the fire of revolution!
  
  What do we need right now? A token that screams innovation, that's what! A token that doesn't play by the rules, 
  but rewrites them. Say hello to PEPE PRINTOOOR, baby! 🚀
  
  We're talking big moves here. We're talking about a total supply of 100 billion tokens. 
  But hold up, we ain't about that whale life. We keep it real with a max wallet and transaction limit of just 2%. 
  Ain't nobody gonna rug us, not on our watch!
  
  Now, let's talk taxes. We're bringing in the heavy hitters with a 4% tax on every buy and sell. 
  But wait, here's the kicker – 3% of that goes straight back to you, the holders, in sweet, sweet PEPE rewards. 
  That's right, stack those Pepe tokens, baby! And the remaining 1%? We're putting that towards buybacks and marketing. 
  We're making moves, we're making noise, and we're taking PEPE PRINTOOOR to the stratosphere!
  
  But hold onto your hats, folks, 'cause we're not stopping there. 
  We're burning the liquidity, renouncing the contract, and paving our own path to the moon!
  No celebrities needed, just a community of believers ready to ride this rocket ship to the stars!
  
  Website, Twitter, TG – all coming soon. 
  Stay safe out there, people, 'cause when PEPE PRINTOOOR hits, 
  it's gonna be one hell of a ride! 🚀🐸 #PEPEPRINTOOOR #ToTheMoonAndBeyond
  */
  pragma solidity 0.8.24;
  // SPDX-License-Identifier: MIT
  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) {
          // Solidity only automatically asserts when dividing by 0
          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;
      }
  }
  
  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"); _;
      }
  
   
      modifier authorized() {
          require(isAuthorized(msg.sender), "!AUTHORIZED"); _;
      }
  
   
      function authorize(address adr) public onlyOwner {
          authorizations[adr] = true;
      }
  
    
      function unauthorize(address adr) public onlyOwner {
          authorizations[adr] = false;
      }
  
      function isOwner(address account) public view returns (bool) {
          return account == owner;
      }
  
      function isAuthorized(address adr) public view returns (bool) {
          return authorizations[adr];
      }
  
      function transferOwnership(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,
          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 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;
  }
  
  interface IRewardsDividends {
      function setDistributionCriteria(
          uint256 _minPeriod,
          uint256 _minDistribution
      ) external;
  
      function setShare(address shareholder, uint256 amount) external;
  
      function deposit() external payable;
  
      function process(uint256 gas) external;
  
      function withdraw(address shareholder) external;
  
      function removeStuckDividends() external;
  }
  
  contract RewardsDividends is IRewardsDividends {
      using SafeMath for uint256;
      address _token;
  
      address public REWARD;
  
      IDEXRouter router;
  
      struct Share {
          uint256 amount;
          uint256 totalExcluded;
          uint256 totalRealised;
      }
  
      address[] shareholders;
      mapping(address => uint256) shareholderIndexes;
      mapping(address => uint256) shareholderClaims;
      mapping(address => Share) public shares;
  
      uint256 public totalShares;
      uint256 public totalDividends;
      uint256 public totalDistributed;
      uint256 public dividendsPerShare;
      uint256 public dividendsPerShareAccuracyFactor = 10**36;
  
      uint256 public minPeriod = 60 minutes;
      uint256 public minDistribution = 1 * (10 ** 18);
  
      uint256 public currentIndex;
      bool initialized;
  
      modifier initialization() {
          require(!initialized);
          _;
          initialized = true;
      }
  
      modifier onlyToken() {
          require(msg.sender == _token);
          _;
      }
  
      constructor() {
          _token = msg.sender;
          router = IDEXRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
          REWARD = 0x6982508145454Ce325dDbE47a25d4ec3d2311933;//PEPE
      }
  
      receive() external payable {
          deposit();
      }
  
      function removeStuckDividends() external onlyToken {
          uint256 balance = IERC20(REWARD).balanceOf(address(this));
  
          IERC20(REWARD).transfer(
              address(msg.sender),
              balance
          );
      }
  
      function setDistributionCriteria(
          uint256 newMinPeriod,
          uint256 newMinDistribution
      ) external override onlyToken {
          minPeriod = newMinPeriod;
          minDistribution = newMinDistribution;
      }
  
      function setShare(address shareholder, uint256 amount)
          external
          override
          onlyToken
      {
          if (shares[shareholder].amount > 0) {
              distributeDividend(shareholder);
          }
  
          if (amount > 0 && shares[shareholder].amount == 0) {
              addShareholder(shareholder);
          } else if (amount == 0 && shares[shareholder].amount > 0) {
              removeShareholder(shareholder);
          }
  
          totalShares = totalShares.sub(shares[shareholder].amount).add(amount);
          shares[shareholder].amount = amount;
          shares[shareholder].totalExcluded = getCumulativeDividends(
              shares[shareholder].amount
          );
      }
  
      function deposit() public payable override {
          uint256 balanceBefore = IERC20(REWARD).balanceOf(address(this));
  
          address[] memory path = new address[](2);
          path[0] = router.WETH();
          path[1] = address(REWARD);
  
          router.swapExactETHForTokensSupportingFeeOnTransferTokens{
              value: msg.value
          }(0, path, address(this), block.timestamp);
  
          uint256 amount = IERC20(REWARD).balanceOf(address(this)).sub(
              balanceBefore
          );
          totalDividends = totalDividends.add(amount);
          dividendsPerShare = dividendsPerShare.add(
              dividendsPerShareAccuracyFactor.mul(amount).div(totalShares)
          );
      }
  
      function process(uint256 gas) external override {
          uint256 shareholderCount = shareholders.length;
  
          if (shareholderCount == 0) {
              return;
          }
  
          uint256 iterations = 0;
          uint256 gasUsed = 0;
          uint256 gasLeft = gasleft();
  
          while (gasUsed < gas && iterations < shareholderCount) {
              if (currentIndex >= shareholderCount) {
                  currentIndex = 0;
              }
  
              if (shouldDistribute(shareholders[currentIndex])) {
                  distributeDividend(shareholders[currentIndex]);
              }
  
              gasUsed = gasUsed.add(gasLeft.sub(gasleft()));
              gasLeft = gasleft();
              currentIndex++;
              iterations++;
          }
      }
  
      function shouldDistribute(address shareholder) public view returns (bool) {
          return
              shareholderClaims[shareholder] + minPeriod < block.timestamp &&
              getUnpaidEarnings(shareholder) > minDistribution;
      }
  
      function distributeDividend(address shareholder) internal {
          if (shares[shareholder].amount == 0) {
              return;
          }
  
          uint256 amount = getUnpaidEarnings(shareholder);
          if (amount > 0) {
              totalDistributed = totalDistributed.add(amount);
              IERC20(REWARD).transfer(shareholder, amount);
              shareholderClaims[shareholder] = block.timestamp;
              shares[shareholder].totalRealised = shares[shareholder]
                  .totalRealised
                  .add(amount);
              shares[shareholder].totalExcluded = getCumulativeDividends(
                  shares[shareholder].amount
              );
          }
      }
  
      function withdraw(address shareholder) external override onlyToken {
          distributeDividend(shareholder);
      }
  
      function getUnpaidEarnings(address shareholder)
          public
          view
          returns (uint256)
      {
          if (shares[shareholder].amount == 0) {
              return 0;
          }
  
          uint256 shareholderTotalDividends = getCumulativeDividends(
              shares[shareholder].amount
          );
          uint256 shareholderTotalExcluded = shares[shareholder].totalExcluded;
  
          if (shareholderTotalDividends <= shareholderTotalExcluded) {
              return 0;
          }
  
          return shareholderTotalDividends.sub(shareholderTotalExcluded);
      }
  
      function getCumulativeDividends(uint256 share)
          internal
          view
          returns (uint256)
      {
          return
              share.mul(dividendsPerShare).div(dividendsPerShareAccuracyFactor);
      }
  
      function addShareholder(address shareholder) internal {
          shareholderIndexes[shareholder] = shareholders.length;
          shareholders.push(shareholder);
      }
  
      function removeShareholder(address shareholder) internal {
          shareholders[shareholderIndexes[shareholder]] = shareholders[
              shareholders.length - 1
          ];
          shareholderIndexes[
              shareholders[shareholders.length - 1]
          ] = shareholderIndexes[shareholder];
          shareholders.pop();
      }
  }
  
  contract PEPRINT is IERC20, Auth {
      using SafeMath for uint256;
  
      address public REWARD = 0x6982508145454Ce325dDbE47a25d4ec3d2311933;//PEPE
      string private constant _name = unicode"PEPE PRINTOOOR";
      string private constant _symbol = unicode"PEPRINT";
      uint8 private constant _decimals = 9;
  
      uint256 private _totalSupply = 100_000_000_000 * (10**_decimals);
  
      mapping(address => uint256) private _balances;
      mapping(address => mapping(address => uint256)) private _allowances;
      mapping(address => uint256) private cooldown;
  
      address private WETH;
      address DEAD = 0x000000000000000000000000000000000000dEaD;
      address ZERO = 0x0000000000000000000000000000000000000000;
  
      mapping(address => bool) public isFeeExempt;
      mapping(address => bool) public isTxLimitExempt;
      mapping(address => bool) public isDividendExempt;
  
      address public lpWallet = msg.sender;
  
      uint256 public buyFee = 4;
      uint256 public sellFee = 4;
  
      uint256 public toReflections = 75;//3%
      uint256 public toMarketing = 25;//1%
  
      uint256 public allocationSum = 100;
  
      IDEXRouter public router;
      address public pair;
      address public factory;
      address private tokenOwner;
      address public devWallet;
  
      bool inSwapAndLiquify;
      bool public swapAndLiquifyEnabled = true;
      bool public tradingOpen = false;
  
      RewardsDividends public rewards;
      uint256 public rewardsGas = 0;
  
      modifier lockTheSwap() {
          inSwapAndLiquify = true;
          _;
          inSwapAndLiquify = false;
      }
  
      uint256 public maxTx = _totalSupply.mul(2).div(100);
      uint256 public maxWallet = _totalSupply.mul(2).div(100);
      uint256 public swapThreshold = _totalSupply.div(400);
  
      constructor(address _owner) Auth(_owner) {
          devWallet = payable(_owner);
  
          router = IDEXRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
  
          WETH = router.WETH();
  
          pair = IDEXFactory(router.factory()).createPair(WETH, address(this));
  
          _allowances[address(this)][address(router)] = type(uint256).max;
  
          rewards = new RewardsDividends();
  
          isFeeExempt[_owner] = true;
          isFeeExempt[devWallet] = true;
  
          isDividendExempt[pair] = true;
          isDividendExempt[address(this)] = true;
          isDividendExempt[DEAD] = true;
  
          isTxLimitExempt[_owner] = true;
          isTxLimitExempt[pair] = true;
          isTxLimitExempt[DEAD] = true;
          isTxLimitExempt[devWallet] = true;
  
          _balances[_owner] = _totalSupply;
  
          emit Transfer(address(0), _owner, _totalSupply);
      }
  
      receive() external payable {}
  
      //once enabled, cannot be reversed
      function enableTrading() external onlyOwner {
          tradingOpen = true;
          buyFee = 20;
          sellFee = 35;
          toReflections = 25;
          toMarketing = 75;
      }
  
       function finalTaxes() external onlyOwner {
          buyFee = 4;
          sellFee = 4;
          toReflections = 75;//3% Rewards
          toMarketing = 25;//1% Mkt
      }
  
      function changeTotalFees(uint256 newBuyFee, uint256 newSellFee)
          external
          onlyOwner
      {
          buyFee = newBuyFee;
          sellFee = newSellFee;
      }
  
      function changeFeeAllocation(uint256 newRewardFee, uint256 newMarketingFee)
          external
          onlyOwner
      {
          toReflections = newRewardFee;
          toMarketing = newMarketingFee;
      }
  
      function changeTxLimit(uint256 newLimit) external onlyOwner {
          require(newLimit >= maxTx, "Can not lower max tx");
          maxTx = newLimit;
      }
  
      function changeWalletLimit(uint256 newLimit) external onlyOwner {
          require(newLimit >= maxWallet, "Can not lower max wallet");
          maxWallet = newLimit;
      }
  
      function changeIsFeeExempt(address holder, bool exempt) external onlyOwner {
          isFeeExempt[holder] = exempt;
      }
  
      function changeIsTxLimitExempt(address holder, bool exempt)
          external
          onlyOwner
      {
          isTxLimitExempt[holder] = exempt;
      }
  
      function setDevWallet(address payable newDevWallet) external onlyOwner {
          devWallet = payable(newDevWallet);
      }
  
      function setOwnerWallet(address payable newOwnerWallet) external onlyOwner {
          tokenOwner = newOwnerWallet;
      }
  
      function changeSwapBackSettings(
          bool enableSwapBack,
          uint256 newSwapBackLimit
      ) external onlyOwner {
          swapAndLiquifyEnabled = enableSwapBack;
          swapThreshold = newSwapBackLimit;
      }
  
      function setDistributionCriteria(
          uint256 newMinPeriod,
          uint256 newMinDistribution
      ) external onlyOwner {
          rewards.setDistributionCriteria(newMinPeriod, newMinDistribution);
      }
  
      function _setIsDividendExempt(address holder, bool exempt) internal {
          require(holder != address(this) && holder != pair);
          isDividendExempt[holder] = exempt;
          if (exempt) {
              rewards.setShare(holder, 0);
          } else {
              rewards.setShare(holder, _balances[holder]);
          }
      }
  
      function setIsDividendExempt(address holder, bool exempt)
          external
          onlyOwner
      {
          _setIsDividendExempt(holder, exempt);
      }
  
      function changeRewardsGas(uint256 newGas) external onlyOwner {
          rewardsGas = newGas;
      }
  
      function getCirculatingSupply() public view returns (uint256) {
          return _totalSupply.sub(balanceOf(DEAD)).sub(balanceOf(ZERO));
      }
  
      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);
      }
  
      function transfer(address recipient, uint256 amount)
          external
          override
          returns (bool)
      {
          return _transfer(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 _transfer(sender, recipient, amount);
      }
  
      function _transfer(
          address sender,
          address recipient,
          uint256 amount
      ) internal returns (bool) {
          if (sender != owner && recipient != owner)
              require(tradingOpen, "hold ur horses big guy."); //transfers disabled before tradingActive
  
          if (inSwapAndLiquify) {
              return _basicTransfer(sender, recipient, amount);
          }
  
          require(amount <= maxTx || isTxLimitExempt[sender], "tx");
  
  
  
          if (!isTxLimitExempt[recipient]) {
              require(_balances[recipient].add(amount) <= maxWallet, "wallet");
          }
  
          if (
              msg.sender != pair &&
              !inSwapAndLiquify &&
              swapAndLiquifyEnabled &&
              _balances[address(this)] >= swapThreshold
          ) {
              swapBack();
          }
  
          _balances[sender] = _balances[sender].sub(
              amount,
              "Insufficient Balance"
          );
  
          uint256 finalAmount = !isFeeExempt[sender] && !isFeeExempt[recipient]
              ? takeFee(sender, recipient, amount)
              : amount;
          _balances[recipient] = _balances[recipient].add(finalAmount);
  
          // Dividend tracker
          if (!isDividendExempt[sender]) {
              try rewards.setShare(sender, _balances[sender]) {} catch {}
          }
  
          if (!isDividendExempt[recipient]) {
              try rewards.setShare(recipient, _balances[recipient]) {} catch {}
          }
  
          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 takeFee(
          address sender,
          address recipient,
          uint256 amount
      ) internal returns (uint256) {
          uint256 feeApplicable = pair == recipient ? sellFee : buyFee;
          uint256 feeAmount = amount.mul(feeApplicable).div(100);
  
          _balances[address(this)] = _balances[address(this)].add(feeAmount);
          emit Transfer(sender, address(this), feeAmount);
  
          return amount.sub(feeAmount);
      }
  
      function swapTokensForEth(uint256 tokenAmount) private {
          address[] memory path = new address[](2);
          path[0] = address(this);
          path[1] = router.WETH();
  
          approve(address(this), tokenAmount);
  
          router.swapExactTokensForETHSupportingFeeOnTransferTokens(
              tokenAmount,
              0, // accept any amount of ETH
              path,
              address(this),
              block.timestamp
          );
      }
  
      function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
          router.addLiquidityETH{value: ethAmount}(
              address(this),
              tokenAmount,
              0,
              0,
              lpWallet,
              block.timestamp
          );
      }
  
      function swapBack() internal lockTheSwap {
          swapTokensForEth(_balances[address(this)]);
  
          uint256 totalEthBalance = address(this).balance;
  
          uint256 ethForREWARD = totalEthBalance.mul(toReflections).div(100);
  
          try rewards.deposit{value: ethForREWARD}() {} catch {}
  
          payable(devWallet).transfer(address(this).balance);
      }
  
      function manualSwapBack() external onlyOwner {
          swapBack();
      }
  
      function clearStuckEth() external onlyOwner {
          uint256 contractETHBalance = address(this).balance;
          if (contractETHBalance > 0) {
              payable(devWallet).transfer(contractETHBalance);
          }
      }
  
      function manualProcessGas(uint256 manualGas) external onlyOwner {
          rewards.process(manualGas);
      }
  
      function checkPendingReflections(address shareholder)
          external
          view
          returns (uint256)
      {
          return rewards.getUnpaidEarnings(shareholder);
      }
  
      function withdrawFromRewards() external {
          rewards.withdraw(msg.sender);
      }
  
      function rescueTokens(address _tokenAddr, address _to, uint _amount) public onlyOwner {
          IERC20(_tokenAddr).transfer(_to, _amount);
      }
  
      function removeStuckDividends() external onlyOwner {
          rewards.removeStuckDividends();
      }
  }