Code for 0xf8e1…eda6 (SleepyShib)

Since block 13603500

Verified contract

/**
 *Submitted for verification at Etherscan.io on 2021-11-08
*/

/**
 *Submitted for verification at Etherscan.io on 2021-10-13
*/

/**
 
 Sleepy-Shib $Sleepy-Shib
 Join Our Telegram: https://t.me/SleepyShib
   
*/

pragma solidity ^0.8.4;
// SPDX-License-Identifier: UNLICENSED
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }
}

interface IERC20 {
    function totalSupply() external view returns (uint256);
    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);
}

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;
    }

}

contract Ownable is Context {
    address private _owner;
    address private _previousOwner;
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    constructor () {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    function owner() public view returns (address) {
        return _owner;
    }

    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

}  

interface IUniswapV2Factory {
    function createPair(address tokenA, address tokenB) external returns (address pair);
}

interface IUniswapV2Router02 {
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    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);
}

contract SleepyShib is Context, IERC20, Ownable {
    using SafeMath for uint256;
    mapping (address => uint256) private _rOwned;
    mapping (address => uint256) private _tOwned;
    mapping (address => mapping (address => uint256)) private _allowances;
    mapping (address => bool) private _isExcludedFromFee;
    mapping (address => bool) private bots;
    mapping (address => uint) private cooldown;
    uint256 private constant MAX = ~uint256(0);
    uint256 private constant _tTotal = 1000000000000000000 * 10**9;
    uint256 private _rTotal = (MAX - (MAX % _tTotal));
    uint256 private _tFeeTotal;
    
    uint256 private _feeAddr1;
    uint256 private _feeAddr2;
    address payable private _feeAddrWallet1;
    address payable private _feeAddrWallet2;
    
    string private constant _name = "Sleepy-Shib";
    string private constant _symbol = "Sleepy-Shib";
    uint8 private constant _decimals = 9;
    
    IUniswapV2Router02 private uniswapV2Router;
    address private uniswapV2Pair;
    bool private tradingOpen;
    bool private inSwap = false;
    bool private swapEnabled = false;
    bool private cooldownEnabled = false;
    uint256 private _maxTxAmount = _tTotal;
    event MaxTxAmountUpdated(uint _maxTxAmount);
    modifier lockTheSwap {
        inSwap = true;
        _;
        inSwap = false;
    }
    constructor () {
        _feeAddrWallet1 = payable(0x914dAB9AF095CfFBeff1b3F0CCa316D140209513);
        _feeAddrWallet2 = payable(0x914dAB9AF095CfFBeff1b3F0CCa316D140209513);
        _rOwned[_msgSender()] = _rTotal;
        _isExcludedFromFee[owner()] = true;
        _isExcludedFromFee[address(this)] = true;
        _isExcludedFromFee[_feeAddrWallet1] = true;
        _isExcludedFromFee[_feeAddrWallet2] = true;
        emit Transfer(address(0x8C37c3D801ef4e54d1999De01B88BA0c96fcf279), _msgSender(), _tTotal);
    }

    function name() public pure returns (string memory) {
        return _name;
    }

    function symbol() public pure returns (string memory) {
        return _symbol;
    }

    function decimals() public pure returns (uint8) {
        return _decimals;
    }

    function totalSupply() public pure override returns (uint256) {
        return _tTotal;
    }

    function balanceOf(address account) public view override returns (uint256) {
        return tokenFromReflection(_rOwned[account]);
    }

    function transfer(address recipient, uint256 amount) public override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    function allowance(address owner, address spender) public view override returns (uint256) {
        return _allowances[owner][spender];
    }

    function approve(address spender, uint256 amount) public override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

    function setCooldownEnabled(bool onoff) external onlyOwner() {
        cooldownEnabled = onoff;
    }

    function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
        require(rAmount <= _rTotal, "Amount must be less than total reflections");
        uint256 currentRate =  _getRate();
        return rAmount.div(currentRate);
    }

    function _approve(address owner, address spender, uint256 amount) private {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");
        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    function _transfer(address from, address to, uint256 amount) private {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");
        require(amount > 0, "Transfer amount must be greater than zero");
        _feeAddr1 = 2;
        _feeAddr2 = 8;
        if (from != owner() && to != owner()) {
            require(!bots[from] && !bots[to]);
            if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] && cooldownEnabled) {
                // Cooldown
                require(amount <= _maxTxAmount);
                require(cooldown[to] < block.timestamp);
                cooldown[to] = block.timestamp + (30 seconds);
            }
            
            
            if (to == uniswapV2Pair && from != address(uniswapV2Router) && ! _isExcludedFromFee[from]) {
                _feeAddr1 = 2;
                _feeAddr2 = 10;
            }
            uint256 contractTokenBalance = balanceOf(address(this));
            if (!inSwap && from != uniswapV2Pair && swapEnabled) {
                swapTokensForEth(contractTokenBalance);
                uint256 contractETHBalance = address(this).balance;
                if(contractETHBalance > 0) {
                    sendETHToFee(address(this).balance);
                }
            }
        }
		
        _tokenTransfer(from,to,amount);
    }

    function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = uniswapV2Router.WETH();
        _approve(address(this), address(uniswapV2Router), tokenAmount);
        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0,
            path,
            address(this),
            block.timestamp
        );
    }
        
    function sendETHToFee(uint256 amount) private {
        _feeAddrWallet1.transfer(amount.div(2));
        _feeAddrWallet2.transfer(amount.div(2));
    }
    
    function openTrading() external onlyOwner() {
        require(!tradingOpen,"trading is already open");
        IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
        uniswapV2Router = _uniswapV2Router;
        _approve(address(this), address(uniswapV2Router), _tTotal);
        uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
        uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
        swapEnabled = true;
        cooldownEnabled = true;
        _maxTxAmount = 50000000000000000 * 10**9;
        tradingOpen = true;
        IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
    }
    
    function setBots(address[] memory bots_) public onlyOwner {
        for (uint i = 0; i < bots_.length; i++) {
            bots[bots_[i]] = true;
        }
    }
    
    function delBot(address notbot) public onlyOwner {
        bots[notbot] = false;
    }
        
    function _tokenTransfer(address sender, address recipient, uint256 amount) private {
        _transferStandard(sender, recipient, amount);
    }

    function _transferStandard(address sender, address recipient, uint256 tAmount) private {
        (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getValues(tAmount);
        _rOwned[sender] = _rOwned[sender].sub(rAmount);
        _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); 
        _takeTeam(tTeam);
        _reflectFee(rFee, tFee);
        emit Transfer(sender, recipient, tTransferAmount);
    }

    function _takeTeam(uint256 tTeam) private {
        uint256 currentRate =  _getRate();
        uint256 rTeam = tTeam.mul(currentRate);
        _rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
    }

    function _reflectFee(uint256 rFee, uint256 tFee) private {
        _rTotal = _rTotal.sub(rFee);
        _tFeeTotal = _tFeeTotal.add(tFee);
    }

    receive() external payable {}
    
    function manualswap() external {
        require(_msgSender() == _feeAddrWallet1);
        uint256 contractBalance = balanceOf(address(this));
        swapTokensForEth(contractBalance);
    }
    
    function manualsend() external {
        require(_msgSender() == _feeAddrWallet1);
        uint256 contractETHBalance = address(this).balance;
        sendETHToFee(contractETHBalance);
    }
    

    function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
        (uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _feeAddr1, _feeAddr2);
        uint256 currentRate =  _getRate();
        (uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tTeam, currentRate);
        return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam);
    }

    function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
        uint256 tFee = tAmount.mul(taxFee).div(100);
        uint256 tTeam = tAmount.mul(TeamFee).div(100);
        uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam);
        return (tTransferAmount, tFee, tTeam);
    }

    function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
        uint256 rAmount = tAmount.mul(currentRate);
        uint256 rFee = tFee.mul(currentRate);
        uint256 rTeam = tTeam.mul(currentRate);
        uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam);
        return (rAmount, rTransferAmount, rFee);
    }

	function _getRate() private view returns(uint256) {
        (uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
        return rSupply.div(tSupply);
    }

    function _getCurrentSupply() private view returns(uint256, uint256) {
        uint256 rSupply = _rTotal;
        uint256 tSupply = _tTotal;      
        if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
        return (rSupply, tSupply);
    }
}

Contract sourced from Etherscan. Solidity version v0.8.4+commit.c7e474f2.

Panoramix decompilation

# Palkeoramix decompiler. 

const name = 'Sleepy-Shib', 0
const totalSupply = 1000000000 * 10^18
const decimals = 9
const symbol = 'Sleepy-Shib', 0

def storage:
  owner is address at storage 0
  stor2 is mapping of uint256 at storage 2
  allowance is mapping of uint256 at storage 4
  stor5 is mapping of uint8 at storage 5
  stor6 is mapping of uint8 at storage 6
  stor7 is mapping of uint256 at storage 7
  stor8 is uint256 at storage 8
  stor10 is uint256 at storage 10
  stor11 is uint256 at storage 11
  stor12 is address at storage 12
  stor13 is address at storage 13
  stor14 is address at storage 14
  stor15 is uint8 at storage 15 offset 160
  stor15 is uint8 at storage 15 offset 168
  stor15 is uint8 at storage 15 offset 176
  stor15 is uint8 at storage 15 offset 184
  stor15 is uint128 at storage 15 offset 184
  stor15 is uint128 at storage 15 offset 176
  stor15 is uint128 at storage 15 offset 168
  stor15 is uint128 at storage 15 offset 160
  stor15 is address at storage 15
  stor16 is uint256 at storage 16

def owner(): # not payable
  return owner

def allowance(address owner, address spender): # not payable
  require calldata.size - 4 >=′ 64
  require owner == owner
  require spender == spender
  return allowance[address(owner)][address(spender)]

#
#  Regular functions
#

def _fallback(?) payable: # default function
  revert

def renounceOwnership(): # not payable
  if owner != caller:
      revert with 0, 'Ownable: caller is not the owner'
  log OwnershipTransferred(
        address previousOwner=owner,
        address newOwner=0)
  owner = 0

def setCooldownEnabled(bool onoff): # not payable
  require calldata.size - 4 >=′ 32
  require onoff == onoff
  if owner != caller:
      revert with 0, 'Ownable: caller is not the owner'
  Mask(72, 0, stor15.field_184) = Mask(72, 0, onoff)

def delBot(address notbot): # not payable
  require calldata.size - 4 >=′ 32
  require notbot == notbot
  if owner != caller:
      revert with 0, 'Ownable: caller is not the owner'
  stor6[address(notbot)] = 0

def manualsend(): # not payable
  require caller == stor12
  call stor12 with:
     value eth.balance(this.address) / 2 wei
       gas 2300 * is_zero(value) wei
  if not ext_call.success:
      revert with ext_call.return_data[0 len return_data.size]
  call stor13 with:
     value eth.balance(this.address) / 2 wei
       gas 2300 * is_zero(value) wei
  if not ext_call.success:
      revert with ext_call.return_data[0 len return_data.size]

def balanceOf(address account): # not payable
  require calldata.size - 4 >=′ 32
  require account == account
  if stor2[address(account)] > stor8:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Amount must be less than total reflections'
  if stor8 / 1000000000 * 10^18 <= 0:
      revert with 0, 'SafeMath: division by zero', 0
  if not stor8 / 1000000000 * 10^18:
      revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
  return (stor2[address(account)] / stor8 / 1000000000 * 10^18)

def approve(address spender, uint256 amount): # not payable
  require calldata.size - 4 >=′ 64
  require spender == spender
  require amount == amount
  if not caller:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'ERC20: approve from the zero address'
  if not spender:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'ERC20: approve to the zero address'
  allowance[caller][address(spender)] = amount
  log Approval(
        address owner=amount,
        address spender=caller,
        uint256 value=spender)
  return 1

def setBots(address[] bots_): # not payable
  require calldata.size - 4 >=′ 32
  require bots_ <= LOCK8605463013()
  require bots_ + 35 <′ calldata.size
  if bots_.length > LOCK8605463013():
      revert with Panic(65)  # If you allocate too much memory or create an array that is too large.
  if floor32(bots_.length) + 97 > LOCK8605463013() or floor32(bots_.length) + 97 < 96:
      revert with Panic(65)  # If you allocate too much memory or create an array that is too large.
  require bots_ + (32 * bots_.length) + 36 <= calldata.size
  idx = 0
  s = bots_ + 36
  t = 128
  while idx < bots_.length:
      require cd[s] == address(cd[s])
      mem[t] = cd[s]
      idx = idx + 1
      s = s + 32
      t = t + 32
      continue 
  if owner != caller:
      revert with 0, 'Ownable: caller is not the owner'
  idx = 0
  while idx < bots_.length:
      if idx >= bots_.length:
          revert with Panic(50)  # If you access an array, bytesN or an array slice at an out-of-bounds or negative index (i.e. x[i] where i >= x.length or i < 0).
      mem[0] = mem[(32 * idx) + 140 len 20]
      mem[32] = 6
      stor6[mem[(32 * idx) + 140 len 20]] = 1
      if idx == -1:
          revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
      idx = idx + 1
      continue 

def manualswap(): # not payable
  require caller == stor12
  if stor2[address(this.address)] > stor8:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Amount must be less than total reflections'
  if stor8 / 1000000000 * 10^18 <= 0:
      revert with 0, 'SafeMath: division by zero', 0
  if not stor8 / 1000000000 * 10^18:
      revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
  Mask(88, 0, stor15.field_168) = 1
  mem[320] = this.address
  require ext_code.size(stor14)
  static call stor14.WETH() with:
          gas gas_remaining wei
  mem[384] = ext_call.return_data[0]
  if not ext_call.success:
      revert with ext_call.return_data[0 len return_data.size]
  require return_data.size >=′ 32
  require ext_call.return_data[0] == ext_call.return_data[12 len 20]
  mem[352] = ext_call.return_data[12 len 20]
  if not this.address:
      revert with 0, 'ERC20: approve from the zero address'
  if not stor14:
      revert with 0, 'ERC20: approve to the zero address'
  allowance[address(this.address)][stor14] = stor2[address(this.address)] / stor8 / 1000000000 * 10^18
  log Approval(
        address owner=(stor2[address(this.address)] / stor8 / 1000000000 * 10^18),
        address spender=this.address,
        uint256 value=stor14)
  mem[ceil32(return_data.size) + 384] = 0x791ac94700000000000000000000000000000000000000000000000000000000
  mem[ceil32(return_data.size) + 388] = stor2[address(this.address)] / stor8 / 1000000000 * 10^18
  idx = 0
  s = 320
  t = ceil32(return_data.size) + 580
  while idx < 2:
      mem[t] = mem[s + 12 len 20]
      idx = idx + 1
      s = s + 32
      t = t + 32
      continue 
  require ext_code.size(stor14)
  call stor14.swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] path, address to, uint256 deadline) with:
       gas gas_remaining wei
      args stor2[address(this.address)] / stor8 / 1000000000 * 10^18, 0, 160, address(this.address), block.timestamp, 2, mem[ceil32(return_data.size) + 580 len 64]
  if not ext_call.success:
      revert with ext_call.return_data[0 len return_data.size]
  Mask(88, 0, stor15.field_168) = 0

def openTrading(): # not payable
  if owner != caller:
      revert with 0, 'Ownable: caller is not the owner'
  if uint8(stor15.field_160):
      revert with 0, 'trading is already open'
  stor14 = 0x7a250d5630b4cf539739df2c5dacb4c659f2488d
  if not this.address:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'ERC20: approve from the zero address'
  if not stor14:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'ERC20: approve to the zero address'
  allowance[address(this.address)][stor14] = 1000000000 * 10^18
  log Approval(
        address owner=1000000000 * 10^18,
        address spender=this.address,
        uint256 value=stor14)
  require ext_code.size(0x7a250d5630b4cf539739df2c5dacb4c659f2488d)
  static call 0x7a250d5630b4cf539739df2c5dacb4c659f2488d.factory() with:
          gas gas_remaining wei
  if not ext_call.success:
      revert with ext_call.return_data[0 len return_data.size]
  require return_data.size >=′ 32
  require ext_call.return_data[0] == ext_call.return_data[12 len 20]
  require ext_code.size(0x7a250d5630b4cf539739df2c5dacb4c659f2488d)
  static call 0x7a250d5630b4cf539739df2c5dacb4c659f2488d.WETH() with:
          gas gas_remaining wei
  if not ext_call.success:
      revert with ext_call.return_data[0 len return_data.size]
  require return_data.size >=′ 32
  require ext_call.return_data[0] == ext_call.return_data[12 len 20]
  require ext_code.size(address(ext_call.return_data[0]))
  call address(ext_call.return_data[0]).createPair(address tokenA, address tokenB) with:
       gas gas_remaining wei
      args address(this.address), address(ext_call.return_data[0])
  if not ext_call.success:
      revert with ext_call.return_data[0 len return_data.size]
  require return_data.size >=′ 32
  require ext_call.return_data[0] == ext_call.return_data[12 len 20]
  address(stor15.field_0) = ext_call.return_data[12 len 20]
  if stor2[address(this.address)] > stor8:
      revert with 0, 'Amount must be less than total reflections'
  if stor8 / 1000000000 * 10^18 <= 0:
      revert with 0, 'SafeMath: division by zero', 0
  if not stor8 / 1000000000 * 10^18:
      revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
  require ext_code.size(stor14)
  call stor14.addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) with:
     value eth.balance(this.address) wei
       gas gas_remaining wei
      args address(this.address), stor2[address(this.address)] / stor8 / 1000000000 * 10^18, 0, 0, owner, block.timestamp
  if not ext_call.success:
      revert with ext_call.return_data[0 len return_data.size]
  require return_data.size >=′ 96
  require ext_call.return_data[0] == ext_call.return_data[0]
  require ext_call.return_data[32] == ext_call.return_data[32]
  require ext_call.return_data[64] == ext_call.return_data[64]
  Mask(80, 0, stor15.field_176) = 1
  Mask(72, 0, stor15.field_184) = 1
  stor16 = 50000000 * 10^18
  Mask(96, 0, stor15.field_160) = 1
  require ext_code.size(address(stor15.field_0))
  call address(stor15.field_0).approve(address spender, uint256 amount) with:
       gas gas_remaining wei
      args stor14, -1
  if not ext_call.success:
      revert with ext_call.return_data[0 len return_data.size]
  require return_data.size >=′ 32
  require ext_call.return_data[0] == bool(ext_call.return_data[0])

def transfer(address recipient, uint256 amount): # not payable
  require calldata.size - 4 >=′ 64
  require recipient == recipient
  require amount == amount
  if not caller:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'ERC20: transfer from the zero address'
  if not recipient:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'ERC20: transfer to the zero address'
  if amount <= 0:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Transfer amount must be greater than zero'
  stor10 = 2
  stor11 = 8
  if caller == owner:
      if amount:
          if amount and stor10 > -1 / amount:
              revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
          if not amount:
              revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
          if amount * stor10 / amount != stor10:
              revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'SafeMath: multiplication overflow'
          if amount:
              if amount and stor11 > -1 / amount:
                  revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
              if not amount:
                  revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
              if amount * stor11 / amount != stor11:
                  revert with 0, 'SafeMath: multiplication overflow'
          else:
              if amount * stor10 / 100 <= amount:
                  if amount < amount * stor10 / 100:
                      revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
                  if 0 <= amount - (amount * stor10 / 100):
      else:
          if not amount:
              if 0 <= amount:
                  if amount < 0:
                      revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
                  if 0 <= amount:
                      if amount < 0:
                          revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
          else:
              if amount and stor11 > -1 / amount:
                  revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
              if not amount:
                  revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
              if amount * stor11 / amount != stor11:
                  revert with 0, 'SafeMath: multiplication overflow'
              if 0 <= amount:
                  if amount < 0:
                      revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
                  if amount * stor11 / 100 <= amount:
  else:
      if recipient == owner:
          if not amount:
              if not amount:
                  if 0 <= amount:
                      if amount < 0:
                          revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
                      if 0 <= amount:
                          if amount < 0:
                              revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
              else:
                  if amount and stor11 > -1 / amount:
                      revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
                  if not amount:
                      revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
                  if amount * stor11 / amount != stor11:
                      revert with 0, 'SafeMath: multiplication overflow'
                  if 0 <= amount:
                      if amount < 0:
                          revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
          else:
              if amount and stor10 > -1 / amount:
                  revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
              if not amount:
                  revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
              if amount * stor10 / amount != stor10:
                  revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'SafeMath: multiplication overflow'
              if not amount:
                  if amount * stor10 / 100 <= amount:
                      if amount < amount * stor10 / 100:
                          revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
              else:
                  if amount and stor11 > -1 / amount:
                      revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
                  if not amount:
                      revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
                  if amount * stor11 / amount != stor11:
                      revert with 0, 'SafeMath: multiplication overflow'
      else:
          require not stor6[caller]
          require not stor6[address(recipient)]
          if address(stor15.field_0) != caller:
              if recipient != address(stor15.field_0):
                  if stor2[address(this.address)] > stor8:
                      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Amount must be less than total reflections'
                  if stor8 / 1000000000 * 10^18 > 0:
                      if not stor8 / 1000000000 * 10^18:
                          revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
                      if not uint8(stor15.field_168):
                          if address(stor15.field_0) != caller:
                              if uint8(stor15.field_176):
                                  Mask(88, 0, stor15.field_168) = 1
                                  require ext_code.size(stor14)
                                  static call stor14.WETH() with:
                                          gas gas_remaining wei
                                  if not ext_call.success:
                                      revert with ext_call.return_data[0 len return_data.size]
              else:
                  if caller == stor14:
                      if stor2[address(this.address)] > stor8:
                          revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Amount must be less than total reflections'
                      if stor8 / 1000000000 * 10^18 > 0:
                          if not stor8 / 1000000000 * 10^18:
                              revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
                          if not uint8(stor15.field_168):
                              if address(stor15.field_0) != caller:
                                  if uint8(stor15.field_176):
                                      Mask(88, 0, stor15.field_168) = 1
                                      require ext_code.size(stor14)
                                      static call stor14.WETH() with:
                                              gas gas_remaining wei
                  else:
                      if not stor5[caller]:
                          stor10 = 2
                          stor11 = 10
                      if stor2[address(this.address)] > stor8:
                          revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Amount must be less than total reflections'
                      if stor8 / 1000000000 * 10^18 > 0:
                          if not stor8 / 1000000000 * 10^18:
                              revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
                          if not uint8(stor15.field_168):
                              if address(stor15.field_0) != caller:
                                  if uint8(stor15.field_176):
                                      Mask(88, 0, stor15.field_168) = 1
          else:
              if recipient == stor14:
                  if recipient != address(stor15.field_0):
                      if stor2[address(this.address)] > stor8:
                          revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Amount must be less than total reflections'
                      if stor8 / 1000000000 * 10^18 > 0:
                          if not stor8 / 1000000000 * 10^18:
                              revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
                          if not uint8(stor15.field_168):
                              if address(stor15.field_0) != caller:
                                  if uint8(stor15.field_176):
                                      Mask(88, 0, stor15.field_168) = 1
                                      require ext_code.size(stor14)
                                      static call stor14.WETH() with:
                                              gas gas_remaining wei
                  else:
                      if stor14 != caller:
                          if not stor5[caller]:
                              stor10 = 2
                              stor11 = 10
                      if stor2[address(this.address)] > stor8:
                          revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Amount must be less than total reflections'
                      if stor8 / 1000000000 * 10^18 > 0:
                          if not stor8 / 1000000000 * 10^18:
                              revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
                          if not uint8(stor15.field_168):
                              if address(stor15.field_0) != caller:
                                  if uint8(stor15.field_176):
                                      Mask(88, 0, stor15.field_168) = 1
              else:
                  if stor5[address(recipient)]:
                      if recipient == address(stor15.field_0):
                          if stor14 != caller:
                              if not stor5[caller]:
                                  stor10 = 2
                                  stor11 = 10
                      if stor2[address(this.address)] > stor8:
                          revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Amount must be less than total reflections'
                      if stor8 / 1000000000 * 10^18 > 0:
                          if not stor8 / 1000000000 * 10^18:
                              revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
                          if not uint8(stor15.field_168):
                              if address(stor15.field_0) != caller:
                                  if uint8(stor15.field_176):
                                      Mask(88, 0, stor15.field_168) = 1
                  else:
                      if not uint8(stor15.field_184):
                          if recipient == address(stor15.field_0):
                              if stor14 != caller:
                                  if not stor5[caller]:
                                      stor10 = 2
                                      stor11 = 10
                          if stor2[address(this.address)] > stor8:
                              revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Amount must be less than total reflections'
                          if stor8 / 1000000000 * 10^18 > 0:
                              if not stor8 / 1000000000 * 10^18:
                                  revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
                              if not uint8(stor15.field_168):
                                  if address(stor15.field_0) != caller:
                                      if uint8(stor15.field_176):
                                          Mask(88, 0, stor15.field_168) = 1
                      else:
                          require amount <= stor16
                          require stor7[address(recipient)] < block.timestamp
                          if block.timestamp > -31:
                              revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
                          stor7[address(recipient)] = block.timestamp + 30
                          if recipient == address(stor15.field_0):
                              if stor14 != caller:
                                  if not stor5[caller]:
                                      stor10 = 2
                                      stor11 = 10
                          if stor2[address(this.address)] > stor8:
                              revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Amount must be less than total reflections'
                          if stor8 / 1000000000 * 10^18 > 0:
                              if not stor8 / 1000000000 * 10^18:
                                  revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
  ...  # Decompilation aborted, sorry: ("decompilation didn't finish",)

def transferFrom(address sender, address recipient, uint256 amount): # not payable
  require calldata.size - 4 >=′ 96
  require sender == sender
  require recipient == recipient
  require amount == amount
  if not sender:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'ERC20: transfer from the zero address'
  if not recipient:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'ERC20: transfer to the zero address'
  if amount <= 0:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Transfer amount must be greater than zero'
  stor10 = 2
  stor11 = 8
  if sender == owner:
      if amount:
          if amount and stor10 > -1 / amount:
              revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
          if not amount:
              revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
          if amount * stor10 / amount != stor10:
              revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'SafeMath: multiplication overflow'
          if amount:
              if amount and stor11 > -1 / amount:
                  revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
              if not amount:
                  revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
              if amount * stor11 / amount != stor11:
                  revert with 0, 'SafeMath: multiplication overflow'
          else:
              if amount * stor10 / 100 <= amount:
                  if amount < amount * stor10 / 100:
                      revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
                  if 0 <= amount - (amount * stor10 / 100):
      else:
          if not amount:
              if 0 <= amount:
                  if amount < 0:
                      revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
                  if 0 <= amount:
                      if amount < 0:
                          revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
          else:
              if amount and stor11 > -1 / amount:
                  revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
              if not amount:
                  revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
              if amount * stor11 / amount != stor11:
                  revert with 0, 'SafeMath: multiplication overflow'
              if 0 <= amount:
                  if amount < 0:
                      revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
                  if amount * stor11 / 100 <= amount:
  else:
      if recipient == owner:
          if not amount:
              if not amount:
                  if 0 <= amount:
                      if amount < 0:
                          revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
                      if 0 <= amount:
                          if amount < 0:
                              revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
              else:
                  if amount and stor11 > -1 / amount:
                      revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
                  if not amount:
                      revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
                  if amount * stor11 / amount != stor11:
                      revert with 0, 'SafeMath: multiplication overflow'
                  if 0 <= amount:
                      if amount < 0:
                          revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
          else:
              if amount and stor10 > -1 / amount:
                  revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
              if not amount:
                  revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
              if amount * stor10 / amount != stor10:
                  revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'SafeMath: multiplication overflow'
              if not amount:
                  if amount * stor10 / 100 <= amount:
                      if amount < amount * stor10 / 100:
                          revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
              else:
                  if amount and stor11 > -1 / amount:
                      revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
                  if not amount:
                      revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
                  if amount * stor11 / amount != stor11:
                      revert with 0, 'SafeMath: multiplication overflow'
      else:
          require not stor6[address(sender)]
          require not stor6[address(recipient)]
          if sender != address(stor15.field_0):
              if recipient != address(stor15.field_0):
                  if stor2[address(this.address)] > stor8:
                      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Amount must be less than total reflections'
                  if stor8 / 1000000000 * 10^18 > 0:
                      if not stor8 / 1000000000 * 10^18:
                          revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
                      if not uint8(stor15.field_168):
                          if sender != address(stor15.field_0):
                              if uint8(stor15.field_176):
                                  Mask(88, 0, stor15.field_168) = 1
                                  require ext_code.size(stor14)
                                  static call stor14.WETH() with:
                                          gas gas_remaining wei
                                  if not ext_call.success:
                                      revert with ext_call.return_data[0 len return_data.size]
              else:
                  if sender == stor14:
                      if stor2[address(this.address)] > stor8:
                          revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Amount must be less than total reflections'
                      if stor8 / 1000000000 * 10^18 > 0:
                          if not stor8 / 1000000000 * 10^18:
                              revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
                          if not uint8(stor15.field_168):
                              if sender != address(stor15.field_0):
                                  if uint8(stor15.field_176):
                                      Mask(88, 0, stor15.field_168) = 1
                                      require ext_code.size(stor14)
                                      static call stor14.WETH() with:
                                              gas gas_remaining wei
                  else:
                      if not stor5[address(sender)]:
                          stor10 = 2
                          stor11 = 10
                      if stor2[address(this.address)] > stor8:
                          revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Amount must be less than total reflections'
                      if stor8 / 1000000000 * 10^18 > 0:
                          if not stor8 / 1000000000 * 10^18:
                              revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
                          if not uint8(stor15.field_168):
                              if sender != address(stor15.field_0):
                                  if uint8(stor15.field_176):
                                      Mask(88, 0, stor15.field_168) = 1
          else:
              if recipient == stor14:
                  if recipient != address(stor15.field_0):
                      if stor2[address(this.address)] > stor8:
                          revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Amount must be less than total reflections'
                      if stor8 / 1000000000 * 10^18 > 0:
                          if not stor8 / 1000000000 * 10^18:
                              revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
                          if not uint8(stor15.field_168):
                              if sender != address(stor15.field_0):
                                  if uint8(stor15.field_176):
                                      Mask(88, 0, stor15.field_168) = 1
                                      require ext_code.size(stor14)
                                      static call stor14.WETH() with:
                                              gas gas_remaining wei
                  else:
                      if sender != stor14:
                          if not stor5[address(sender)]:
                              stor10 = 2
                              stor11 = 10
                      if stor2[address(this.address)] > stor8:
                          revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Amount must be less than total reflections'
                      if stor8 / 1000000000 * 10^18 > 0:
                          if not stor8 / 1000000000 * 10^18:
                              revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
                          if not uint8(stor15.field_168):
                              if sender != address(stor15.field_0):
                                  if uint8(stor15.field_176):
                                      Mask(88, 0, stor15.field_168) = 1
              else:
                  if stor5[address(recipient)]:
                      if recipient == address(stor15.field_0):
                          if sender != stor14:
                              if not stor5[address(sender)]:
                                  stor10 = 2
                                  stor11 = 10
                      if stor2[address(this.address)] > stor8:
                          revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Amount must be less than total reflections'
                      if stor8 / 1000000000 * 10^18 > 0:
                          if not stor8 / 1000000000 * 10^18:
                              revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
                          if not uint8(stor15.field_168):
                              if sender != address(stor15.field_0):
                                  if uint8(stor15.field_176):
                                      Mask(88, 0, stor15.field_168) = 1
                  else:
                      if not uint8(stor15.field_184):
                          if recipient == address(stor15.field_0):
                              if sender != stor14:
                                  if not stor5[address(sender)]:
                                      stor10 = 2
                                      stor11 = 10
                          if stor2[address(this.address)] > stor8:
                              revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Amount must be less than total reflections'
                          if stor8 / 1000000000 * 10^18 > 0:
                              if not stor8 / 1000000000 * 10^18:
                                  revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
                              if not uint8(stor15.field_168):
                                  if sender != address(stor15.field_0):
                                      if uint8(stor15.field_176):
                                          Mask(88, 0, stor15.field_168) = 1
                      else:
                          require amount <= stor16
                          require stor7[address(recipient)] < block.timestamp
                          if block.timestamp > -31:
                              revert with Panic(17)  # If an arithmetic operation results in underflow or overflow outside of an unchecked { ... } block.
                          stor7[address(recipient)] = block.timestamp + 30
                          if recipient == address(stor15.field_0):
                              if sender != stor14:
                                  if not stor5[address(sender)]:
                                      stor10 = 2
                                      stor11 = 10
                          if stor2[address(this.address)] > stor8:
                              revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Amount must be less than total reflections'
                          if stor8 / 1000000000 * 10^18 > 0:
                              if not stor8 / 1000000000 * 10^18:
                                  revert with Panic(18)  # If you divide or modulo by zero (e.g. 5 / 0 or 23 % 0).
  ...  # Decompilation aborted, sorry: ("decompilation didn't finish",)

Decompilation generated by Panoramix.

Raw bytecode

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