Untitled
unknown
plain_text
3 years ago
48 kB
6
Indexable
#
# 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
Editor is loading...