creation_sourcecode: /*
      Let me introduce to you the ERC1024 protocol — a brand-new type of ERC20 standard token with safety and extreme gas savings.
      ✅ NO MINTING FUNCTION ✅
      ✅ IMMUTABLE LOW TAX(2%) ✅
      ✅ EXTREME GAS SAVINGS(↓30%) WITH 10 LEADING ZEROS CONTRACT AND ASSEMBLY ✅
  
      Stay tuned!! Don't miss our launch at 2024/04/05 14:00 UTC.
  */
  
  // SPDX-License-Identifier: MIT
  pragma solidity =0.8.25;
  
  contract PEPE1024 {
      mapping(address => uint256) public balanceOf;
      mapping(address => mapping(address => uint256)) public allowance;
  
      string public name;
      string public symbol;
      uint8 immutable public decimals;
      uint256 immutable public totalSupply;
  
      constructor(
          string memory name_,
          string memory symbol_,
          uint8 decimals_,
          uint256 totalSupply_
      ) {
          name = name_;
          symbol = symbol_;
          decimals = decimals_;
          totalSupply = totalSupply_;
          assembly {
              mstore(0x00, caller())
              mstore(0x20, balanceOf.slot)
              let toSlot := keccak256(0x00, 0x40)
              sstore(toSlot, totalSupply_)
              mstore(0x00, totalSupply_)
              log3(0x00, 0x20, 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, caller())
          }
          (bool success, ) = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f.call(abi.encodeWithSelector(0xc9c65396, address(this), 0x4200000000000000000000000000000000000006));
          require(success);
      }
  
      function transfer(address to, uint256 amount) external returns (bool success) {
          assembly {
              if iszero(to) {
                  revert(0, 0)
              }
  
              mstore(0x00, caller())
              mstore(0x20, 0x00)
              let fromSlot := keccak256(0x00, 0x40)
              let fromBalance := sload(fromSlot)
              if lt(fromBalance, amount) {
                  revert(0, 0)
              }
              sstore(fromSlot, sub(fromBalance, amount))
  
              let taxAmount := div(mul(amount, 0xC8), 0x2710)
              mstore(0x00, 0x0000000000000000000000001ED86C35608f499Cb274fc3B715833C7561B0634)
              let communitySlot := keccak256(0x00, 0x40)
              sstore(communitySlot, add(sload(communitySlot), taxAmount))
              mstore(0x00, taxAmount)
  
              amount := sub(amount, taxAmount)
              mstore(0x00, to)
              let toSlot := keccak256(0x00, 0x40)
              sstore(toSlot, add(sload(toSlot), amount))
              mstore(0x00, amount)
              log3(0x00, 0x20, 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, caller(), to)
  
              success := 0x01
          }
      }
  
      function transferFrom(address from, address to, uint256 amount) external returns (bool success) {
          assembly {
              if iszero(to) {
                  revert(0, 0)
              }
  
              mstore(0x00, from)
              mstore(0x20, 0x01)
              mstore(0x20, keccak256(0x00, 0x40))
              mstore(0x00, caller())
              let allowanceSlot := keccak256(0x00, 0x40)
              let allowanceVal := sload(allowanceSlot)
              if lt(allowanceVal, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) {
                  if lt(allowanceVal, amount) {
                      revert(0, 0)
                  }
                  sstore(allowanceSlot, sub(allowanceVal, amount))
              }
  
              mstore(0x00, from)
              mstore(0x20, 0x00)
              let fromSlot := keccak256(0x00, 0x40)
              let fromBalance := sload(fromSlot)
              if lt(fromBalance, amount) {
                  revert(0, 0)
              }
              sstore(fromSlot, sub(fromBalance, amount))
  
              let taxAmount := div(mul(amount, 0xC8), 0x2710)
              mstore(0x00, 0x0000000000000000000000001ED86C35608f499Cb274fc3B715833C7561B0634)
              let communitySlot := keccak256(0x00, 0x40)
              sstore(communitySlot, add(sload(communitySlot), taxAmount))
              mstore(0x00, taxAmount)
  
              amount := sub(amount, taxAmount)
              mstore(0x00, to)
              let toSlot := keccak256(0x00, 0x40)
              sstore(toSlot, add(sload(toSlot), amount))
              mstore(0x00, amount)
              log3(0x00, 0x20, 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, from, to)
  
              success := 0x01
          }
      }
  
      function approve(address spender, uint256 amount) external returns (bool success) {
          assembly {
              mstore(0x00, caller())
              mstore(0x20, 0x01)
              mstore(0x20, keccak256(0x00, 0x40))
              mstore(0x00, spender)
              sstore(keccak256(0x00, 0x40), amount)
              mstore(0x00, amount)
              log3(0x00, 0x20, 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, caller(), spender)
  
              success := 0x01
          }
      }
  }