Untitled

mail@pastecode.io avatar
unknown
plain_text
2 years ago
48 kB
2
Indexable
Never
#
#  Panoramix v4 Oct 2019 
#  Decompiled source of bsc:0x8CD70b1D8d21c3e06F4505Fb3890288aDC9aB72c
# 
#  Let's make the world open source 
# 

const unknown1694505e = 0x10ed43c718714eb63d5aa57b78b54704e256024e
const unknown27c8f835 = 57005
const unknown49bd5a5e = 0x42172210bbe6687c5774249e838f5de9402b283a

def storage:
  owner is addr at storage 0
  stor1 is addr at storage 1
  stor2 is uint256 at storage 2
  marketingAddress is addr at storage 3
  balanceOf is mapping of uint256 at storage 4
  allowance is mapping of uint256 at storage 6
  stor7 is mapping of uint8 at storage 7
  stor8 is mapping of uint8 at storage 8
  totalSupply is uint256 at storage 10
  stor12 is array of struct at storage 12
  stor13 is array of struct at storage 13
  decimals is uint8 at storage 14
  unknownd6b513cf is uint256 at storage 15
  unknown7d1db4a5 is uint256 at storage 16
  stor17 is uint8 at storage 17 offset 16
  stor17 is uint256 at storage 17 offset 8
  unknown4a74bb02 is uint8 at storage 17 offset 8
  stor17 is uint256 at storage 17 offset 16

def totalSupply(): # not payable
  return totalSupply

def decimals(): # not payable
  return decimals

def unknown4a74bb02(): # not payable
  return bool(unknown4a74bb02)

def balanceOf(address _owner): # not payable
  require calldata.size - 4 >=′ 32
  require _owner == _owner
  return balanceOf[addr(_owner)]

def unknown7d1db4a5(): # not payable
  return unknown7d1db4a5

def owner(): # not payable
  return owner

def unknown9cee2142(uint256 _param1): # not payable
  require calldata.size - 4 >=′ 32
  require _param1 == addr(_param1)
  return bool(stor8[_param1])

def marketingAddress(): # not payable
  return marketingAddress

def unknownd6b513cf(): # not payable
  return unknownd6b513cf

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

#
#  Regular functions
#

def unknownb0cb81f1(uint256 _param1): # not payable
  require calldata.size - 4 >=′ 32
  if owner != caller:
      revert with 0, 'Ownable: caller is not the owner'
  unknownd6b513cf = _param1

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

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

def unknown30d35dee(uint256 _param1): # not payable
  require calldata.size - 4 >=′ 32
  require _param1 == bool(_param1)
  if owner != caller:
      revert with 0, 'Ownable: caller is not the owner'
  Mask(240, 0, stor17.field_16) = Mask(240, 0, bool(_param1))

def unknown437823ec(uint256 _param1): # not payable
  require calldata.size - 4 >=′ 32
  require _param1 == addr(_param1)
  if owner != caller:
      revert with 0, 'Ownable: caller is not the owner'
  stor7[addr(_param1)] = 1

def unknownc49b9a80(uint256 _param1): # not payable
  require calldata.size - 4 >=′ 32
  require _param1 == bool(_param1)
  if owner != caller:
      revert with 0, 'Ownable: caller is not the owner'
  Mask(248, 0, stor17.field_8) = Mask(248, 0, bool(_param1))
  log 0x53726dfc: bool(_param1)

def unlock(): # not payable
  if stor1 != caller:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'You don't have permission to unlock'
  if block.timestamp <= stor2:
      revert with 0, 'Contract is locked until 7 days'
  log OwnershipTransferred(
        address previousOwner=owner,
        address newOwner=stor1)
  owner = stor1

def unknown7d654c7f(uint256 _param1): # not payable
  require calldata.size - 4 >=′ 32
  if owner != caller:
      revert with 0, 'Ownable: caller is not the owner'
  stor1 = owner
  owner = 0
  if block.timestamp > !_param1:
      revert with 0, 17
  stor2 = block.timestamp + _param1
  log OwnershipTransferred(
        address previousOwner=owner,
        address newOwner=0)

def approve(address _spender, uint256 _value): # not payable
  require calldata.size - 4 >=′ 64
  require _spender == _spender
  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][addr(_spender)] = _value
  log Approval(
        address owner=_value,
        address spender=caller,
        uint256 value=_spender)
  return 1

def burn(uint256 _value): # not payable
  require calldata.size - 4 >=′ 32
  if owner != caller:
      revert with 0, 'Ownable: caller is not the owner'
  if not caller:
      revert with 0, 'ERC20: to the zero address'
  if totalSupply > !_value:
      revert with 0, 17
  if totalSupply + _value < totalSupply:
      revert with 0, 'SafeMath: addition overflow'
  totalSupply += _value
  if balanceOf[caller] > !_value:
      revert with 0, 17
  if balanceOf[caller] + _value < balanceOf[caller]:
      revert with 0, 'SafeMath: addition overflow'
  balanceOf[caller] += _value
  log 0x65ddf252: _value, 0, caller

def transfer(address _to, uint256 _value): # not payable
  require calldata.size - 4 >=′ 64
  require _to == _to
  if not caller:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'ERC20: transfer from the zero address'
  if not _to:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'ERC20: transfer to the zero address'
  if _value <= 0:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Transfer amount must be greater than zero'
  if uint8(stor17.field_16):
      if bool(stor8[addr(_to)]) != 1:
          if bool(stor8[caller]) != 1:
              if caller != caller:
                  revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Coin Contract : You're not on whitelisted.'
  if _value > balanceOf[caller]:
      revert with 0, 'SafeMath: subtraction overflow', 0
  if balanceOf[caller] < _value:
      revert with 0, 17
  balanceOf[caller] -= _value
  if balanceOf[_to] > !_value:
      revert with 0, 17
  if balanceOf[_to] + _value < balanceOf[_to]:
      revert with 0, 'SafeMath: addition overflow'
  balanceOf[addr(_to)] = balanceOf[_to] + _value
  if stor7[caller]:
      log 0x65ddf252: _value, caller, _to
  else:
      if stor7[addr(_to)]:
          log 0x65ddf252: _value, caller, _to
      else:
          if stor8[caller]:
              log 0x65ddf252: _value, caller, _to
          else:
              if stor8[addr(_to)]:
                  log 0x65ddf252: _value, caller, _to
              else:
                  if _value / 100 and unknownd6b513cf > -1 / _value / 100:
                      revert with 0, 17
                  if _value / 100 * unknownd6b513cf > balanceOf[addr(_to)]:
                      revert with 0, 'SafeMath: subtraction overflow', 0
                  if balanceOf[addr(_to)] < _value / 100 * unknownd6b513cf:
                      revert with 0, 17
                  balanceOf[addr(_to)] += -1 * _value / 100 * unknownd6b513cf
                  if _value / 100 and unknownd6b513cf > -1 / _value / 100:
                      revert with 0, 17
                  if _value / 100 * unknownd6b513cf > _value:
                      revert with 0, 'SafeMath: subtraction overflow', 0
                  if _value < _value / 100 * unknownd6b513cf:
                      revert with 0, 17
                  if _value / 100 and unknownd6b513cf > -1 / _value / 100:
                      revert with 0, 17
                  if balanceOf[stor3] > !(_value / 100 * unknownd6b513cf):
                      revert with 0, 17
                  if balanceOf[stor3] + (_value / 100 * unknownd6b513cf) < balanceOf[stor3]:
                      revert with 0, 'SafeMath: addition overflow'
                  balanceOf[stor3] += _value / 100 * unknownd6b513cf
                  if _value / 100 and unknownd6b513cf > -1 / _value / 100:
                      revert with 0, 17
                  log 0x65ddf252: (_value / 100 * unknownd6b513cf), caller, marketingAddress
                  log 0x65ddf252: (_value - (_value / 100 * unknownd6b513cf)), caller, _to
  return 1

def name(): # not payable
  if bool(stor12.length):
      if bool(stor12.length) == uint255(stor12.length) * 0.5 < 32:
          revert with 0, 34
      if bool(stor12.length):
          if bool(stor12.length) == uint255(stor12.length) * 0.5 < 32:
              revert with 0, 34
          if Mask(256, -1, stor12.length):
              if 31 < uint255(stor12.length) * 0.5:
                  mem[128] = uint256(stor12.field_0)
                  idx = 128
                  s = 0
                  while (uint255(stor12.length) * 0.5) + 96 > idx:
                      mem[idx + 32] = stor12[s].field_256
                      idx = idx + 32
                      s = s + 1
                      continue 
                  return Array(len=2 * Mask(256, -1, stor12.length), data=mem[128 len ceil32(uint255(stor12.length) * 0.5)])
              mem[128] = 256 * stor12.length.field_8
      else:
          if bool(stor12.length) == stor12.length.field_1 < 32:
              revert with 0, 34
          if stor12.length.field_1:
              if 31 < stor12.length.field_1:
                  mem[128] = uint256(stor12.field_0)
                  idx = 128
                  s = 0
                  while stor12.length.field_1 + 96 > idx:
                      mem[idx + 32] = stor12[s].field_256
                      idx = idx + 32
                      s = s + 1
                      continue 
                  return Array(len=2 * Mask(256, -1, stor12.length), data=mem[128 len ceil32(uint255(stor12.length) * 0.5)])
              mem[128] = 256 * stor12.length.field_8
      mem[ceil32(uint255(stor12.length) * 0.5) + 192 len ceil32(uint255(stor12.length) * 0.5)] = mem[128 len ceil32(uint255(stor12.length) * 0.5)]
      if ceil32(uint255(stor12.length) * 0.5) > uint255(stor12.length) * 0.5:
          mem[ceil32(uint255(stor12.length) * 0.5) + (uint255(stor12.length) * 0.5) + 192] = 0
      return Array(len=2 * Mask(256, -1, stor12.length), data=mem[128 len ceil32(uint255(stor12.length) * 0.5)], mem[(2 * ceil32(uint255(stor12.length) * 0.5)) + 192 len 2 * ceil32(uint255(stor12.length) * 0.5)]), 
  if bool(stor12.length) == stor12.length.field_1 < 32:
      revert with 0, 34
  if bool(stor12.length):
      if bool(stor12.length) == uint255(stor12.length) * 0.5 < 32:
          revert with 0, 34
      if Mask(256, -1, stor12.length):
          if 31 < uint255(stor12.length) * 0.5:
              mem[128] = uint256(stor12.field_0)
              idx = 128
              s = 0
              while (uint255(stor12.length) * 0.5) + 96 > idx:
                  mem[idx + 32] = stor12[s].field_256
                  idx = idx + 32
                  s = s + 1
                  continue 
              return Array(len=stor12.length % 128, data=mem[128 len ceil32(stor12.length.field_1)])
          mem[128] = 256 * stor12.length.field_8
  else:
      if bool(stor12.length) == stor12.length.field_1 < 32:
          revert with 0, 34
      if stor12.length.field_1:
          if 31 < stor12.length.field_1:
              mem[128] = uint256(stor12.field_0)
              idx = 128
              s = 0
              while stor12.length.field_1 + 96 > idx:
                  mem[idx + 32] = stor12[s].field_256
                  idx = idx + 32
                  s = s + 1
                  continue 
              return Array(len=stor12.length % 128, data=mem[128 len ceil32(stor12.length.field_1)])
          mem[128] = 256 * stor12.length.field_8
  mem[ceil32(stor12.length.field_1) + 192 len ceil32(stor12.length.field_1)] = mem[128 len ceil32(stor12.length.field_1)]
  if ceil32(stor12.length.field_1) > stor12.length.field_1:
      mem[ceil32(stor12.length.field_1) + stor12.length.field_1 + 192] = 0
  return Array(len=stor12.length % 128, data=mem[128 len ceil32(stor12.length.field_1)], mem[(2 * ceil32(stor12.length.field_1)) + 192 len 2 * ceil32(stor12.length.field_1)]), 

def symbol(): # not payable
  if bool(stor13.length):
      if bool(stor13.length) == uint255(stor13.length) * 0.5 < 32:
          revert with 0, 34
      if bool(stor13.length):
          if bool(stor13.length) == uint255(stor13.length) * 0.5 < 32:
              revert with 0, 34
          if Mask(256, -1, stor13.length):
              if 31 < uint255(stor13.length) * 0.5:
                  mem[128] = uint256(stor13.field_0)
                  idx = 128
                  s = 0
                  while (uint255(stor13.length) * 0.5) + 96 > idx:
                      mem[idx + 32] = stor13[s].field_256
                      idx = idx + 32
                      s = s + 1
                      continue 
                  return Array(len=2 * Mask(256, -1, stor13.length), data=mem[128 len ceil32(uint255(stor13.length) * 0.5)])
              mem[128] = 256 * stor13.length.field_8
      else:
          if bool(stor13.length) == stor13.length.field_1 < 32:
              revert with 0, 34
          if stor13.length.field_1:
              if 31 < stor13.length.field_1:
                  mem[128] = uint256(stor13.field_0)
                  idx = 128
                  s = 0
                  while stor13.length.field_1 + 96 > idx:
                      mem[idx + 32] = stor13[s].field_256
                      idx = idx + 32
                      s = s + 1
                      continue 
                  return Array(len=2 * Mask(256, -1, stor13.length), data=mem[128 len ceil32(uint255(stor13.length) * 0.5)])
              mem[128] = 256 * stor13.length.field_8
      mem[ceil32(uint255(stor13.length) * 0.5) + 192 len ceil32(uint255(stor13.length) * 0.5)] = mem[128 len ceil32(uint255(stor13.length) * 0.5)]
      if ceil32(uint255(stor13.length) * 0.5) > uint255(stor13.length) * 0.5:
          mem[ceil32(uint255(stor13.length) * 0.5) + (uint255(stor13.length) * 0.5) + 192] = 0
      return Array(len=2 * Mask(256, -1, stor13.length), data=mem[128 len ceil32(uint255(stor13.length) * 0.5)], mem[(2 * ceil32(uint255(stor13.length) * 0.5)) + 192 len 2 * ceil32(uint255(stor13.length) * 0.5)]), 
  if bool(stor13.length) == stor13.length.field_1 < 32:
      revert with 0, 34
  if bool(stor13.length):
      if bool(stor13.length) == uint255(stor13.length) * 0.5 < 32:
          revert with 0, 34
      if Mask(256, -1, stor13.length):
          if 31 < uint255(stor13.length) * 0.5:
              mem[128] = uint256(stor13.field_0)
              idx = 128
              s = 0
              while (uint255(stor13.length) * 0.5) + 96 > idx:
                  mem[idx + 32] = stor13[s].field_256
                  idx = idx + 32
                  s = s + 1
                  continue 
              return Array(len=stor13.length % 128, data=mem[128 len ceil32(stor13.length.field_1)])
          mem[128] = 256 * stor13.length.field_8
  else:
      if bool(stor13.length) == stor13.length.field_1 < 32:
          revert with 0, 34
      if stor13.length.field_1:
          if 31 < stor13.length.field_1:
              mem[128] = uint256(stor13.field_0)
              idx = 128
              s = 0
              while stor13.length.field_1 + 96 > idx:
                  mem[idx + 32] = stor13[s].field_256
                  idx = idx + 32
                  s = s + 1
                  continue 
              return Array(len=stor13.length % 128, data=mem[128 len ceil32(stor13.length.field_1)])
          mem[128] = 256 * stor13.length.field_8
  mem[ceil32(stor13.length.field_1) + 192 len ceil32(stor13.length.field_1)] = mem[128 len ceil32(stor13.length.field_1)]
  if ceil32(stor13.length.field_1) > stor13.length.field_1:
      mem[ceil32(stor13.length.field_1) + stor13.length.field_1 + 192] = 0
  return Array(len=stor13.length % 128, data=mem[128 len ceil32(stor13.length.field_1)], mem[(2 * ceil32(stor13.length.field_1)) + 192 len 2 * ceil32(stor13.length.field_1)]), 

def transferFrom(address _from, address _to, uint256 _value): # not payable
  require calldata.size - 4 >=′ 96
  require _from == _from
  require _to == _to
  if not _from:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'ERC20: transfer from the zero address'
  if not _to:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'ERC20: transfer to the zero address'
  if _value <= 0:
      revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Transfer amount must be greater than zero'
  if uint8(stor17.field_16):
      if bool(stor8[addr(_to)]) != 1:
          if bool(stor8[addr(_from)]) != 1:
              if _from != caller:
                  revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Coin Contract : You're not on whitelisted.'
  if _value > balanceOf[addr(_from)]:
      revert with 0, 'SafeMath: subtraction overflow', 0
  if balanceOf[addr(_from)] < _value:
      revert with 0, 17
  balanceOf[addr(_from)] -= _value
  if balanceOf[_to] > !_value:
      revert with 0, 17
  if balanceOf[_to] + _value < balanceOf[_to]:
      revert with 0, 'SafeMath: addition overflow'
  balanceOf[addr(_to)] = balanceOf[_to] + _value
  if stor7[addr(_from)]:
      log 0x65ddf252: _value, _from, _to
      if _value > allowance[addr(_from)][caller]:
          revert with 0, 
                      32,
                      40,
                      0xfe45524332303a207472616e7366657220616d6f756e74206578636565647320616c6c6f77616e63, mem[232 len 24] >> 64,
                      0
  else:
      if stor7[addr(_to)]:
          log 0x65ddf252: _value, _from, _to
          if _value > allowance[addr(_from)][caller]:
              revert with 0, 
                          32,
                          40,
                          0xfe45524332303a207472616e7366657220616d6f756e74206578636565647320616c6c6f77616e63, mem[232 len 24] >> 64,
                          0
      else:
          if stor8[addr(_from)]:
              log 0x65ddf252: _value, _from, _to
              if _value > allowance[addr(_from)][caller]:
                  revert with 0, 
                              32,
                              40,
                              0xfe45524332303a207472616e7366657220616d6f756e74206578636565647320616c6c6f77616e63, mem[232 len 24] >> 64,
                              0
          else:
              if stor8[addr(_to)]:
                  log 0x65ddf252: _value, _from, _to
                  if _value > allowance[addr(_from)][caller]:
                      revert with 0, 
                                  32,
                                  40,
                                  0xfe45524332303a207472616e7366657220616d6f756e74206578636565647320616c6c6f77616e63, mem[232 len 24] >> 64,
                                  0
              else:
                  if _value / 100 and unknownd6b513cf > -1 / _value / 100:
                      revert with 0, 17
                  if _value / 100 * unknownd6b513cf > balanceOf[addr(_to)]:
                      revert with 0, 'SafeMath: subtraction overflow', 0
                  if balanceOf[addr(_to)] < _value / 100 * unknownd6b513cf:
                      revert with 0, 17
                  balanceOf[addr(_to)] += -1 * _value / 100 * unknownd6b513cf
                  if _value / 100 and unknownd6b513cf > -1 / _value / 100:
                      revert with 0, 17
                  if _value / 100 * unknownd6b513cf > _value:
                      revert with 0, 'SafeMath: subtraction overflow', 0
                  if _value < _value / 100 * unknownd6b513cf:
                      revert with 0, 17
                  if _value / 100 and unknownd6b513cf > -1 / _value / 100:
                      revert with 0, 17
                  if balanceOf[stor3] > !(_value / 100 * unknownd6b513cf):
                      revert with 0, 17
                  if balanceOf[stor3] + (_value / 100 * unknownd6b513cf) < balanceOf[stor3]:
                      revert with 0, 'SafeMath: addition overflow'
                  balanceOf[stor3] += _value / 100 * unknownd6b513cf
                  if _value / 100 and unknownd6b513cf > -1 / _value / 100:
                      revert with 0, 17
                  log 0x65ddf252: (_value / 100 * unknownd6b513cf), _from, marketingAddress
                  log 0x65ddf252: (_value - (_value / 100 * unknownd6b513cf)), _from, _to
                  if _value > allowance[addr(_from)][caller]:
                      revert with 0, 
                                  32,
                                  40,
                                  0xfe45524332303a207472616e7366657220616d6f756e74206578636565647320616c6c6f77616e63, mem[360 len 24] >> 64,
                                  0
  ('le', ('param', '_value'), ('stor', ('map', 'caller', ('map', ('mask_shl', 160, 0, 0, ('param', '_from')), ('name', 'allowance', 6)))))
  if allowance[addr(_from)][caller] < _value:
      revert with 0, 17
  if not _from:
      revert with 0, 'ERC20: approve from the zero address'
  if not caller:
      revert with 0, 'ERC20: approve to the zero address'
  allowance[addr(_from)][caller] = allowance[addr(_from)][caller] - _value
  log Approval(
        address owner=(allowance[addr(_from)][caller] - _value),
        address spender=_from,
        uint256 value=caller)
  return 1

def _fallback() payable: # default function
  if calldata.size < 4:
      require not calldata.size
      stop
  if removeWhitelist(address account) <= uint32(call.func_hash) >> 224:
      if unlock() > uint32(call.func_hash) >> 224:
          if owner() > uint32(call.func_hash) >> 224:
              if removeWhitelist(address account) == uint32(call.func_hash) >> 224:
                  require not call.value
                  require calldata.size - 4 >=′ 32
                  require _param1 == addr(_param1)
                  if owner != caller:
                      revert with 0, 'Ownable: caller is not the owner'
                  stor8[addr(_param1)] = 0
              else:
                  if 2099098789 == uint32(call.func_hash) >> 224:
                      require not call.value
                      return unknown7d1db4a5
                  require 2103790719 == uint32(call.func_hash) >> 224
                  require not call.value
                  require calldata.size - 4 >=′ 32
                  if owner != caller:
                      revert with 0, 'Ownable: caller is not the owner'
                  stor1 = owner
                  owner = 0
                  if block.timestamp > !_param1:
                      revert with 0, 17
                  stor2 = block.timestamp + _param1
                  log OwnershipTransferred(
                        address previousOwner=owner,
                        address newOwner=0)
              stop
          if owner() == uint32(call.func_hash) >> 224:
              require not call.value
              return owner
          if uint32(call.func_hash) >> 224 != symbol():
              if uint32(call.func_hash) >> 224 != 2632851778:
                  require marketingAddress() == uint32(call.func_hash) >> 224
                  require not call.value
                  return marketingAddress
              require not call.value
              require calldata.size - 4 >=′ 32
              require _param1 == addr(_param1)
              return bool(stor8[_param1])
          require not call.value
          if bool(stor13.length):
              if bool(stor13.length) == uint255(stor13.length) * 0.5 < 32:
                  revert with 0, 34
              if bool(stor13.length):
                  if bool(stor13.length) == uint255(stor13.length) * 0.5 < 32:
                      revert with 0, 34
                  if Mask(256, -1, stor13.length):
                      if 31 < uint255(stor13.length) * 0.5:
                          mem[160] = uint256(stor13.field_0)
                          idx = 160
                          s = 0
                          while (uint255(stor13.length) * 0.5) + 128 > idx:
                              mem[idx + 32] = stor13[s].field_256
                              idx = idx + 32
                              s = s + 1
                              continue 
                          return Array(len=2 * Mask(256, -1, stor13.length), data=mem[160 len ceil32(uint255(stor13.length) * 0.5)])
                      mem[160] = 256 * stor13.length.field_8
              else:
                  if bool(stor13.length) == stor13.length.field_1 < 32:
                      revert with 0, 34
                  if stor13.length.field_1:
                      if 31 < stor13.length.field_1:
                          mem[160] = uint256(stor13.field_0)
                          idx = 160
                          s = 0
                          while stor13.length.field_1 + 128 > idx:
                              mem[idx + 32] = stor13[s].field_256
                              idx = idx + 32
                              s = s + 1
                              continue 
                          return Array(len=2 * Mask(256, -1, stor13.length), data=mem[160 len ceil32(uint255(stor13.length) * 0.5)])
                      mem[160] = 256 * stor13.length.field_8
              mem[ceil32(uint255(stor13.length) * 0.5) + 224 len ceil32(uint255(stor13.length) * 0.5)] = mem[160 len ceil32(uint255(stor13.length) * 0.5)]
              if ceil32(uint255(stor13.length) * 0.5) > uint255(stor13.length) * 0.5:
                  mem[ceil32(uint255(stor13.length) * 0.5) + (uint255(stor13.length) * 0.5) + 224] = 0
              return Array(len=2 * Mask(256, -1, stor13.length), data=mem[160 len ceil32(uint255(stor13.length) * 0.5)], mem[(2 * ceil32(uint255(stor13.length) * 0.5)) + 224 len 2 * ceil32(uint255(stor13.length) * 0.5)]), 
          if bool(stor13.length) == stor13.length.field_1 < 32:
              revert with 0, 34
          if bool(stor13.length):
              if bool(stor13.length) == uint255(stor13.length) * 0.5 < 32:
                  revert with 0, 34
              if Mask(256, -1, stor13.length):
                  if 31 < uint255(stor13.length) * 0.5:
                      mem[160] = uint256(stor13.field_0)
                      idx = 160
                      s = 0
                      while (uint255(stor13.length) * 0.5) + 128 > idx:
                          mem[idx + 32] = stor13[s].field_256
                          idx = idx + 32
                          s = s + 1
                          continue 
                      return Array(len=stor13.length % 128, data=mem[160 len ceil32(stor13.length.field_1)])
                  mem[160] = 256 * stor13.length.field_8
          else:
              if bool(stor13.length) == stor13.length.field_1 < 32:
                  revert with 0, 34
              if stor13.length.field_1:
                  if 31 < stor13.length.field_1:
                      mem[160] = uint256(stor13.field_0)
                      idx = 160
                      s = 0
                      while stor13.length.field_1 + 128 > idx:
                          mem[idx + 32] = stor13[s].field_256
                          idx = idx + 32
                          s = s + 1
                          continue 
                      return Array(len=stor13.length % 128, data=mem[160 len ceil32(stor13.length.field_1)])
                  mem[160] = 256 * stor13.length.field_8
          mem[ceil32(stor13.length.field_1) + 224 len ceil32(stor13.length.field_1)] = mem[160 len ceil32(stor13.length.field_1)]
          if ceil32(stor13.length.field_1) > stor13.length.field_1:
              mem[ceil32(stor13.length.field_1) + stor13.length.field_1 + 224] = 0
          return Array(len=stor13.length % 128, data=mem[160 len ceil32(stor13.length.field_1)], mem[(2 * ceil32(stor13.length.field_1)) + 224 len 2 * ceil32(stor13.length.field_1)]), 
      if 3298531968 <= uint32(call.func_hash) >> 224:
          if 3298531968 == uint32(call.func_hash) >> 224:
              require not call.value
              require calldata.size - 4 >=′ 32
              require _param1 == bool(_param1)
              if owner != caller:
                  revert with 0, 'Ownable: caller is not the owner'
              Mask(248, 0, stor17.field_8) = Mask(248, 0, bool(_param1))
              log 0x53726dfc: bool(_param1)
          else:
              if 3602191311 == uint32(call.func_hash) >> 224:
                  require not call.value
                  return unknownd6b513cf
              if allowance(address owner, address spender) == uint32(call.func_hash) >> 224:
                  require not call.value
                  require calldata.size - 4 >=′ 64
                  require _param1 == addr(_param1)
                  require _param2 == addr(_param2)
                  return allowance[addr(_param1)][addr(_param2)]
              require addWhitelist(address account) == uint32(call.func_hash) >> 224
              require not call.value
              require calldata.size - 4 >=′ 32
              require _param1 == addr(_param1)
              if owner != caller:
                  revert with 0, 'Ownable: caller is not the owner'
              stor8[addr(_param1)] = 1
          stop
      if unlock() == uint32(call.func_hash) >> 224:
          require not call.value
          if stor1 != caller:
              revert with 0, 'You don't have permission to unlock'
          if block.timestamp <= stor2:
              revert with 0, 'Contract is locked until 7 days'
          log OwnershipTransferred(
                address previousOwner=owner,
                address newOwner=stor1)
          owner = stor1
          stop
      if uint32(call.func_hash) >> 224 != transfer(address to, uint256 value):
          require 2966127089 == uint32(call.func_hash) >> 224
          require not call.value
          require calldata.size - 4 >=′ 32
          if owner != caller:
              revert with 0, 'Ownable: caller is not the owner'
          unknownd6b513cf = _param1
          stop
      require not call.value
      require calldata.size - 4 >=′ 64
      require _param1 == addr(_param1)
      if not caller:
          revert with 0, 'ERC20: transfer from the zero address'
      if not addr(_param1):
          revert with 0, 'ERC20: transfer to the zero address'
      if _param2 <= 0:
          revert with 0, 'Transfer amount must be greater than zero'
      if uint8(stor17.field_16):
          if bool(stor8[addr(_param1)]) != 1:
              if bool(stor8[caller]) != 1:
                  if caller != caller:
                      revert with 0, 'Coin Contract : You're not on whitelisted.'
      if _param2 > balanceOf[caller]:
          revert with 0, 'SafeMath: subtraction overflow', 0
      if balanceOf[caller] < _param2:
          revert with 0, 17
      balanceOf[caller] -= _param2
      if balanceOf[addr(_param1)] > !_param2:
          revert with 0, 17
      if balanceOf[addr(_param1)] + _param2 < balanceOf[addr(_param1)]:
          revert with 0, 'SafeMath: addition overflow'
      balanceOf[addr(_param1)] += _param2
      if stor7[caller]:
          log 0x65ddf252: _param2, caller, addr(_param1)
      else:
          if stor7[addr(_param1)]:
              log 0x65ddf252: _param2, caller, addr(_param1)
          else:
              if stor8[caller]:
                  log 0x65ddf252: _param2, caller, addr(_param1)
              else:
                  if stor8[addr(_param1)]:
                      log 0x65ddf252: _param2, caller, addr(_param1)
                  else:
                      if _param2 / 100 and unknownd6b513cf > -1 / _param2 / 100:
                          revert with 0, 17
                      if _param2 / 100 * unknownd6b513cf > balanceOf[addr(_param1)]:
                          revert with 0, 'SafeMath: subtraction overflow', 0
                      if balanceOf[addr(_param1)] < _param2 / 100 * unknownd6b513cf:
                          revert with 0, 17
                      balanceOf[addr(_param1)] += -1 * _param2 / 100 * unknownd6b513cf
                      if _param2 / 100 and unknownd6b513cf > -1 / _param2 / 100:
                          revert with 0, 17
                      if _param2 / 100 * unknownd6b513cf > _param2:
                          revert with 0, 'SafeMath: subtraction overflow', 0
                      if _param2 < _param2 / 100 * unknownd6b513cf:
                          revert with 0, 17
                      if _param2 / 100 and unknownd6b513cf > -1 / _param2 / 100:
                          revert with 0, 17
                      if balanceOf[stor3] > !(_param2 / 100 * unknownd6b513cf):
                          revert with 0, 17
                      if balanceOf[stor3] + (_param2 / 100 * unknownd6b513cf) < balanceOf[stor3]:
                          revert with 0, 'SafeMath: addition overflow'
                      balanceOf[stor3] += _param2 / 100 * unknownd6b513cf
                      if _param2 / 100 and unknownd6b513cf > -1 / _param2 / 100:
                          revert with 0, 17
                      log 0x65ddf252: (_param2 / 100 * unknownd6b513cf), caller, marketingAddress
                      log 0x65ddf252: (_param2 - (_param2 / 100 * unknownd6b513cf)), caller, addr(_param1)
  else:
      if 819158510 <= uint32(call.func_hash) >> 224:
          if 1131946988 <= uint32(call.func_hash) >> 224:
              if 1131946988 == uint32(call.func_hash) >> 224:
                  require not call.value
                  require calldata.size - 4 >=′ 32
                  require _param1 == addr(_param1)
                  if owner != caller:
                      revert with 0, 'Ownable: caller is not the owner'
                  stor7[addr(_param1)] = 1
                  stop
              if 1237146206 == uint32(call.func_hash) >> 224:
                  require not call.value
                  return 0x42172210bbe6687c5774249e838f5de9402b283a
              if 1249164034 == uint32(call.func_hash) >> 224:
                  require not call.value
                  return bool(unknown4a74bb02)
              require balanceOf(address owner) == uint32(call.func_hash) >> 224
              require not call.value
              require calldata.size - 4 >=′ 32
              require _param1 == addr(_param1)
              return balanceOf[addr(_param1)]
          if 819158510 == uint32(call.func_hash) >> 224:
              require not call.value
              require calldata.size - 4 >=′ 32
              require _param1 == bool(_param1)
              if owner != caller:
                  revert with 0, 'Ownable: caller is not the owner'
              Mask(240, 0, stor17.field_16) = Mask(240, 0, bool(_param1))
          else:
              if decimals() == uint32(call.func_hash) >> 224:
                  require not call.value
                  return decimals
              require burn(uint256 value) == uint32(call.func_hash) >> 224
              require not call.value
              require calldata.size - 4 >=′ 32
              if owner != caller:
                  revert with 0, 'Ownable: caller is not the owner'
              if not caller:
                  revert with 0, 'ERC20: to the zero address'
              if totalSupply > !_param1:
                  revert with 0, 17
              if totalSupply + _param1 < totalSupply:
                  revert with 0, 'SafeMath: addition overflow'
              totalSupply += _param1
              if balanceOf[caller] > !_param1:
                  revert with 0, 17
              if balanceOf[caller] + _param1 < balanceOf[caller]:
                  revert with 0, 'SafeMath: addition overflow'
              balanceOf[caller] += _param1
              log 0x65ddf252: _param1, 0, caller
          stop
      if name() == uint32(call.func_hash) >> 224:
          require not call.value
          if bool(stor12.length):
              if bool(stor12.length) == uint255(stor12.length) * 0.5 < 32:
                  revert with 0, 34
              if bool(stor12.length):
                  if bool(stor12.length) == uint255(stor12.length) * 0.5 < 32:
                      revert with 0, 34
                  if Mask(256, -1, stor12.length):
                      if 31 < uint255(stor12.length) * 0.5:
                          mem[160] = uint256(stor12.field_0)
                          idx = 160
                          s = 0
                          while (uint255(stor12.length) * 0.5) + 128 > idx:
                              mem[idx + 32] = stor12[s].field_256
                              idx = idx + 32
                              s = s + 1
                              continue 
                          return Array(len=2 * Mask(256, -1, stor12.length), data=mem[160 len ceil32(uint255(stor12.length) * 0.5)])
                      mem[160] = 256 * stor12.length.field_8
              else:
                  if bool(stor12.length) == stor12.length.field_1 < 32:
                      revert with 0, 34
                  if stor12.length.field_1:
                      if 31 < stor12.length.field_1:
                          mem[160] = uint256(stor12.field_0)
                          idx = 160
                          s = 0
                          while stor12.length.field_1 + 128 > idx:
                              mem[idx + 32] = stor12[s].field_256
                              idx = idx + 32
                              s = s + 1
                              continue 
                          return Array(len=2 * Mask(256, -1, stor12.length), data=mem[160 len ceil32(uint255(stor12.length) * 0.5)])
                      mem[160] = 256 * stor12.length.field_8
              mem[ceil32(uint255(stor12.length) * 0.5) + 224 len ceil32(uint255(stor12.length) * 0.5)] = mem[160 len ceil32(uint255(stor12.length) * 0.5)]
              if ceil32(uint255(stor12.length) * 0.5) > uint255(stor12.length) * 0.5:
                  mem[ceil32(uint255(stor12.length) * 0.5) + (uint255(stor12.length) * 0.5) + 224] = 0
              return Array(len=2 * Mask(256, -1, stor12.length), data=mem[160 len ceil32(uint255(stor12.length) * 0.5)], mem[(2 * ceil32(uint255(stor12.length) * 0.5)) + 224 len 2 * ceil32(uint255(stor12.length) * 0.5)]), 
          if bool(stor12.length) == stor12.length.field_1 < 32:
              revert with 0, 34
          if bool(stor12.length):
              if bool(stor12.length) == uint255(stor12.length) * 0.5 < 32:
                  revert with 0, 34
              if Mask(256, -1, stor12.length):
                  if 31 < uint255(stor12.length) * 0.5:
                      mem[160] = uint256(stor12.field_0)
                      idx = 160
                      s = 0
                      while (uint255(stor12.length) * 0.5) + 128 > idx:
                          mem[idx + 32] = stor12[s].field_256
                          idx = idx + 32
                          s = s + 1
                          continue 
                      return Array(len=stor12.length % 128, data=mem[160 len ceil32(stor12.length.field_1)])
                  mem[160] = 256 * stor12.length.field_8
          else:
              if bool(stor12.length) == stor12.length.field_1 < 32:
                  revert with 0, 34
              if stor12.length.field_1:
                  if 31 < stor12.length.field_1:
                      mem[160] = uint256(stor12.field_0)
                      idx = 160
                      s = 0
                      while stor12.length.field_1 + 128 > idx:
                          mem[idx + 32] = stor12[s].field_256
                          idx = idx + 32
                          s = s + 1
                          continue 
                      return Array(len=stor12.length % 128, data=mem[160 len ceil32(stor12.length.field_1)])
                  mem[160] = 256 * stor12.length.field_8
          mem[ceil32(stor12.length.field_1) + 224 len ceil32(stor12.length.field_1)] = mem[160 len ceil32(stor12.length.field_1)]
          if ceil32(stor12.length.field_1) > stor12.length.field_1:
              mem[ceil32(stor12.length.field_1) + stor12.length.field_1 + 224] = 0
          return Array(len=stor12.length % 128, data=mem[160 len ceil32(stor12.length.field_1)], mem[(2 * ceil32(stor12.length.field_1)) + 224 len 2 * ceil32(stor12.length.field_1)]), 
      if approve(address spender, uint256 value) == uint32(call.func_hash) >> 224:
          require not call.value
          require calldata.size - 4 >=′ 64
          require _param1 == addr(_param1)
          if not caller:
              revert with 0, 'ERC20: approve from the zero address'
          if not addr(_param1):
              revert with 0, 'ERC20: approve to the zero address'
          allowance[caller][addr(_param1)] = _param2
          log Approval(
                address owner=_param2,
                address spender=caller,
                uint256 value=addr(_param1))
      else:
          if 378818654 == uint32(call.func_hash) >> 224:
              require not call.value
              return 0x10ed43c718714eb63d5aa57b78b54704e256024e
          if totalSupply() == uint32(call.func_hash) >> 224:
              require not call.value
              return totalSupply
          if uint32(call.func_hash) >> 224 != transferFrom(address from, address to, uint256 value):
              require 667482165 == uint32(call.func_hash) >> 224
              require not call.value
              return 57005
          require not call.value
          require calldata.size - 4 >=′ 96
          require _param1 == addr(_param1)
          require _param2 == addr(_param2)
          if not addr(_param1):
              revert with 0, 'ERC20: transfer from the zero address'
          if not addr(_param2):
              revert with 0, 'ERC20: transfer to the zero address'
          if _param3 <= 0:
              revert with 0, 'Transfer amount must be greater than zero'
          if uint8(stor17.field_16):
              if bool(stor8[addr(_param2)]) != 1:
                  if bool(stor8[addr(_param1)]) != 1:
                      if addr(_param1) != caller:
                          revert with 0, 'Coin Contract : You're not on whitelisted.'
          if _param3 > balanceOf[addr(_param1)]:
              revert with 0, 'SafeMath: subtraction overflow', 0
          if balanceOf[addr(_param1)] < _param3:
              revert with 0, 17
          balanceOf[addr(_param1)] -= _param3
          if balanceOf[addr(_param2)] > !_param3:
              revert with 0, 17
          if balanceOf[addr(_param2)] + _param3 < balanceOf[addr(_param2)]:
              revert with 0, 'SafeMath: addition overflow'
          balanceOf[addr(_param2)] += _param3
          if stor7[addr(_param1)]:
              log 0x65ddf252: _param3, addr(_param1), addr(_param2)
              if _param3 > allowance[addr(_param1)][caller]:
                  revert with 0, 
                              32,
                              40,
                              0xfe45524332303a207472616e7366657220616d6f756e74206578636565647320616c6c6f77616e63, mem[264 len 24] >> 64,
                              0
          else:
              if stor7[addr(_param2)]:
                  log 0x65ddf252: _param3, addr(_param1), addr(_param2)
                  if _param3 > allowance[addr(_param1)][caller]:
                      revert with 0, 
                                  32,
                                  40,
                                  0xfe45524332303a207472616e7366657220616d6f756e74206578636565647320616c6c6f77616e63, mem[264 len 24] >> 64,
                                  0
              else:
                  if stor8[addr(_param1)]:
                      log 0x65ddf252: _param3, addr(_param1), addr(_param2)
                      if _param3 > allowance[addr(_param1)][caller]:
                          revert with 0, 
                                      32,
                                      40,
                                      0xfe45524332303a207472616e7366657220616d6f756e74206578636565647320616c6c6f77616e63, mem[264 len 24] >> 64,
                                      0
                  else:
                      if stor8[addr(_param2)]:
                          log 0x65ddf252: _param3, addr(_param1), addr(_param2)
                          if _param3 > allowance[addr(_param1)][caller]:
                              revert with 0, 
                                          32,
                                          40,
                                          0xfe45524332303a207472616e7366657220616d6f756e74206578636565647320616c6c6f77616e63, mem[264 len 24] >> 64,
                                          0
                      else:
                          if _param3 / 100 and unknownd6b513cf > -1 / _param3 / 100:
                              revert with 0, 17
                          if _param3 / 100 * unknownd6b513cf > balanceOf[addr(_param2)]:
                              revert with 0, 'SafeMath: subtraction overflow', 0
                          if balanceOf[addr(_param2)] < _param3 / 100 * unknownd6b513cf:
                              revert with 0, 17
                          balanceOf[addr(_param2)] += -1 * _param3 / 100 * unknownd6b513cf
                          if _param3 / 100 and unknownd6b513cf > -1 / _param3 / 100:
                              revert with 0, 17
                          if _param3 / 100 * unknownd6b513cf > _param3:
                              revert with 0, 'SafeMath: subtraction overflow', 0
                          if _param3 < _param3 / 100 * unknownd6b513cf:
                              revert with 0, 17
                          if _param3 / 100 and unknownd6b513cf > -1 / _param3 / 100:
                              revert with 0, 17
                          if balanceOf[stor3] > !(_param3 / 100 * unknownd6b513cf):
                              revert with 0, 17
                          if balanceOf[stor3] + (_param3 / 100 * unknownd6b513cf) < balanceOf[stor3]:
                              revert with 0, 'SafeMath: addition overflow'
                          balanceOf[stor3] += _param3 / 100 * unknownd6b513cf
                          if _param3 / 100 and unknownd6b513cf > -1 / _param3 / 100:
                              revert with 0, 17
                          log 0x65ddf252: (_param3 / 100 * unknownd6b513cf), addr(_param1), marketingAddress
                          log 0x65ddf252: (_param3 - (_param3 / 100 * unknownd6b513cf)), addr(_param1), addr(_param2)
                          if _param3 > allowance[addr(_param1)][caller]:
                              revert with 0, 
                                          32,
                                          40,
                                          0xfe45524332303a207472616e7366657220616d6f756e74206578636565647320616c6c6f77616e63, mem[392 len 24] >> 64,
                                          0
          ('le', ('param', '_param3'), ('stor', ('map', 'caller', ('map', ('mask_shl', 160, 0, 0, ('param', '_param1')), ('name', 'allowance', 6)))))
          if allowance[addr(_param1)][caller] < _param3:
              revert with 0, 17
          if not addr(_param1):
              revert with 0, 'ERC20: approve from the zero address'
          if not caller:
              revert with 0, 'ERC20: approve to the zero address'
          allowance[addr(_param1)][caller] = allowance[addr(_param1)][caller] - _param3
          log Approval(
                address owner=(allowance[addr(_param1)][caller] - _param3),
                address spender=addr(_param1),
                uint256 value=caller)
  return 1