Skip to content

Instantly share code, notes, and snippets.

@zh

zh/contract.v.py

Last active November 4, 2021 10:28
Show Gist options
  • Save zh/f1bb99bcf24ea56e325133012217ba63 to your computer and use it in GitHub Desktop.
Save zh/f1bb99bcf24ea56e325133012217ba63 to your computer and use it in GitHub Desktop.
Download ZIP
woocommerce closed source contract (decompiled)
Raw
contract.v.py
#
# Panoramix v4 Oct 2019
# Decompiled source of 0xd0E4e3A739A454386DA9957432b170C006327B0d
#
# Let's make the world open source
#
def storage:
owner is addr at storage 0
stor1 is mapping of uint8 at storage 1
finalized is uint8 at storage 2 offset 8
stor2 is uint8 at storage 2
stor3 is mapping of uint8 at storage 3
unknown3c57e809 is mapping of struct at storage 4
feeAccount1 is addr at storage 5
feeAccount2 is addr at storage 6
feeAccountToken is addr at storage 7
feePercent is uint256 at storage 8
maxFee is uint256 at storage 9
def maxFee(): # not payable
return maxFee
def isAdmin(address _account): # not payable
require calldata.size - 4 >= 32
if not _account:
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000,
32,
34,
0x77526f6c65733a206163636f756e7420697320746865207a65726f20616464726573,
mem[198 len 30]
return bool(stor1[addr(_account)])
def unknown3c57e809(addr _param1, uint128 _param2, uint256 _param3): # not payable
require calldata.size - 4 >= 96
return unknown3c57e809[_param1][Mask(128, 128, _param2)][_param3].field_0,
unknown3c57e809[_param1][Mask(128, 128, _param2)][_param3].field_256,
unknown3c57e809[_param1][Mask(128, 128, _param2)][_param3].field_512
def feeAccount2(): # not payable
return feeAccount2
def unknown7eabaa28(addr _param1, uint128 _param2, uint256 _param3): # not payable
require calldata.size - 4 >= 96
return unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_512
def feePercent(): # not payable
return feePercent
def unknown89978605(addr _param1, uint128 _param2, uint256 _param3): # not payable
require calldata.size - 4 >= 96
return unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_256
def owner(): # not payable
return owner
def feeAccount1(): # not payable
return feeAccount1
def finalized(): # not payable
return bool(finalized)
def unknowncb9e416c(addr _param1, uint128 _param2, uint256 _param3): # not payable
require calldata.size - 4 >= 96
return unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_0
def feeAccountToken(): # not payable
return feeAccountToken
#
# Regular functions
#
def _fallback() payable: # default function
revert
def isOwner(): # not payable
return (caller == owner)
def unknownd5fbe801(): # not payable
require calldata.size - 4 >= 96
revert with 0, 'Fake method call requested'
def unknownbda0437a(): # not payable
require calldata.size - 4 >= 160
revert with 0, 'Fake method call requested'
def unknown8153c803(): # not payable
if owner != caller:
revert with 0, 'Ownable: caller is not the owner'
require not finalized
finalized = 1
log Finalized()
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 setFeePercent(uint256 _feePercent): # not payable
require calldata.size - 4 >= 32
if owner != caller:
revert with 0, 'Ownable: caller is not the owner'
require _feePercent <= maxFee
feePercent = _feePercent
def unknown249cb3fa(uint256 _param1, addr _param2): # not payable
require calldata.size - 4 >= 64
if stor3[_param1][addr(_param2)]:
return sha3('ERC1820_ACCEPT_MAGIC')
else:
return 0
def transferOwnership(address _newOwner): # not payable
require calldata.size - 4 >= 32
if owner != caller:
revert with 0, 'Ownable: caller is not the owner'
if not _newOwner:
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000,
32,
38,
0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061646472657300,
mem[202 len 26]
log OwnershipTransferred(
address previousOwner=owner,
address newOwner=_newOwner)
owner = _newOwner
def unknown4f1c3e92(): # not payable
if not stor2:
revert with 0, 32, 31, 0xfe5265656e7472616e637947756172643a207265656e7472616e742063616c6c
stor2 = 0
if eth.balance(this.address) / 2 > eth.balance(this.address):
revert with 0, 'SafeMath: subtraction overflow'
call feeAccount1 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 feeAccount2 with:
value eth.balance(this.address) - (eth.balance(this.address) / 2) wei
gas 2300 * is_zero(value) wei
stor2 = 1
def unknown8bad0c0a(): # not payable
if not caller:
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000,
32,
34,
0x77526f6c65733a206163636f756e7420697320746865207a65726f20616464726573,
mem[198 len 30]
if not stor1[caller]:
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000,
32,
33,
0x6e526f6c65733a206163636f756e7420646f6573206e6f74206861766520726f6c,
mem[197 len 31]
stor1[caller] = 0
log AdminRemoved(address address=caller)
def addAdmin(address _admin): # not payable
require calldata.size - 4 >= 32
if not caller:
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000,
32,
34,
0x77526f6c65733a206163636f756e7420697320746865207a65726f20616464726573,
mem[198 len 30]
require stor1[caller]
if not _admin:
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000,
32,
34,
0x77526f6c65733a206163636f756e7420697320746865207a65726f20616464726573,
mem[198 len 30]
if stor1[addr(_admin)]:
revert with 0, 'Roles: account already has role'
stor1[addr(_admin)] = 1
log AdminAdded(address address=_admin)
def unknownacddb131(addr _param1, uint128 _param2, uint256 _param3) payable:
require calldata.size - 4 >= 96
if not stor2:
revert with 0, 32, 31, 0xfe5265656e7472616e637947756172643a207265656e7472616e742063616c6c
stor2 = 0
require not finalized
require _param1
require _param3
require call.value
require not unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_256
if not call.value:
if 0 > call.value:
revert with 0, 'SafeMath: subtraction overflow'
require call.value
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_0 = caller
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_256 = call.value
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_512 = 1
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_520 = 0
log 0xcb15aeed: Mask(128, 128, _param2), call.value, 1, _param1, _param3
call _param1 with:
value call.value wei
gas 2300 * is_zero(value) wei
else:
if feePercent * call.value / call.value != feePercent:
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000,
32,
33,
0x65536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f,
mem[197 len 31]
if feePercent * call.value / 100 * 10^6 > call.value:
revert with 0, 'SafeMath: subtraction overflow'
require call.value - (feePercent * call.value / 100 * 10^6)
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_0 = caller
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_256 = call.value
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_512 = 1
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_520 = 0
log 0xcb15aeed: Mask(128, 128, _param2), call.value, 1, _param1, _param3
call _param1 with:
value call.value - (feePercent * call.value / 100 * 10^6) wei
gas 2300 * is_zero(value) wei
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
stor2 = 1
def unknownc2fd81cc(addr _param1, addr _param2, uint128 _param3, uint256 _param4, uint256 _param5): # not payable
require calldata.size - 4 >= 160
if not stor2:
revert with 0, 32, 31, 0xfe5265656e7472616e637947756172643a207265656e7472616e742063616c6c
stor2 = 0
require not finalized
require _param1
require _param2
require _param4
require _param5
require not unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_256
require ext_code.size(_param1)
static call _param1.allowance(address owner, address spender) with:
gas gas_remaining wei
args caller, this.address
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 >= _param5
if not _param5:
if 0 > _param5:
revert with 0, 'SafeMath: subtraction overflow'
require _param5
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_0 = caller
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_256 = _param5
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_512 = _param1
log 0xcb15aeed: Mask(128, 128, _param3), _param5, _param1, _param2, _param4
require ext_code.size(_param1)
static call _param1.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(_param1)
call _param1.transferFrom(address from, address to, uint256 value) with:
gas gas_remaining wei
args caller, feeAccountToken, 0
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(_param1)
static call _param1.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[437 len 15]
require ext_code.size(_param1)
call _param1.transferFrom(address from, address to, uint256 value) with:
gas gas_remaining wei
args caller, addr(_param2), _param5
else:
if feePercent * _param5 / _param5 != feePercent:
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000,
32,
33,
0x65536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f,
mem[197 len 31]
if feePercent * _param5 / 100 * 10^6 > _param5:
revert with 0, 'SafeMath: subtraction overflow'
require _param5 - (feePercent * _param5 / 100 * 10^6)
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_0 = caller
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_256 = _param5
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_512 = _param1
log 0xcb15aeed: Mask(128, 128, _param3), _param5, _param1, _param2, _param4
require ext_code.size(_param1)
static call _param1.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(_param1)
call _param1.transferFrom(address from, address to, uint256 value) with:
gas gas_remaining wei
args caller, feeAccountToken, feePercent * _param5 / 100 * 10^6
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(_param1)
static call _param1.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if (feePercent * _param5 / 100 * 10^6) + ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if (feePercent * _param5 / 100 * 10^6) + ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[437 len 15]
require ext_code.size(_param1)
call _param1.transferFrom(address from, address to, uint256 value) with:
gas gas_remaining wei
args caller, addr(_param2), _param5 - (feePercent * _param5 / 100 * 10^6)
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
stor2 = 1
def unknown7a0a8e50(addr _param1, uint128 _param2, uint256 _param3, addr _param4, uint256 _param5) payable:
require calldata.size - 4 >= 160
if not stor2:
revert with 0, 32, 31, 0xfe5265656e7472616e637947756172643a207265656e7472616e742063616c6c
stor2 = 0
require not finalized
require _param1
require _param3
require call.value
require not unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_256
if not call.value:
if 0 > call.value:
revert with 0, 'SafeMath: subtraction overflow'
require call.value
if not _param4:
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_0 = caller
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_256 = call.value
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_512 = 1
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_520 = 0
log 0xcb15aeed: Mask(128, 128, _param2), call.value, 1, _param1, _param3
call _param1 with:
value call.value wei
gas 2300 * is_zero(value) wei
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
else:
if _param5 <= 0:
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_0 = caller
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_256 = call.value
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_512 = 1
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_520 = 0
log 0xcb15aeed: Mask(128, 128, _param2), call.value, 1, _param1, _param3
call _param1 with:
value call.value wei
gas 2300 * is_zero(value) wei
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
else:
require _param5 < 100 * 10^6
if not call.value:
if 0 > call.value:
revert with 0, 'SafeMath: subtraction overflow'
require call.value
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_0 = caller
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_256 = call.value
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_512 = 1
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_520 = 0
log 0xcb15aeed: Mask(128, 128, _param2), call.value, 1, _param1, _param3
call _param1 with:
value call.value wei
gas 2300 * is_zero(value) wei
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
else:
if _param5 * call.value / call.value != _param5:
revert with 0, 32, 33, 0x65536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f, mem[325 len 31]
if _param5 * call.value / 100 * 10^6 > call.value:
revert with 0, 'SafeMath: subtraction overflow'
require call.value - (_param5 * call.value / 100 * 10^6)
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_0 = caller
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_256 = call.value
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_512 = 1
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_520 = 0
log 0xcb15aeed: Mask(128, 128, _param2), call.value, 1, _param1, _param3
if not _param5 * call.value / 100 * 10^6:
call _param1 with:
value call.value - (_param5 * call.value / 100 * 10^6) wei
gas 2300 * is_zero(value) wei
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
else:
call _param4 with:
value _param5 * call.value / 100 * 10^6 wei
gas 2300 * is_zero(value) wei
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
call _param1 with:
value call.value - (_param5 * call.value / 100 * 10^6) wei
gas 2300 * is_zero(value) wei
else:
if feePercent * call.value / call.value != feePercent:
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000,
32,
33,
0x65536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f,
mem[197 len 31]
if feePercent * call.value / 100 * 10^6 > call.value:
revert with 0, 'SafeMath: subtraction overflow'
require call.value - (feePercent * call.value / 100 * 10^6)
if not _param4:
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_0 = caller
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_256 = call.value
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_512 = 1
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_520 = 0
log 0xcb15aeed: Mask(128, 128, _param2), call.value, 1, _param1, _param3
call _param1 with:
value call.value - (feePercent * call.value / 100 * 10^6) wei
gas 2300 * is_zero(value) wei
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
else:
if _param5 <= 0:
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_0 = caller
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_256 = call.value
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_512 = 1
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_520 = 0
log 0xcb15aeed: Mask(128, 128, _param2), call.value, 1, _param1, _param3
call _param1 with:
value call.value - (feePercent * call.value / 100 * 10^6) wei
gas 2300 * is_zero(value) wei
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
else:
require _param5 < 100 * 10^6
if not call.value:
if 0 > call.value - (feePercent * call.value / 100 * 10^6):
revert with 0, 'SafeMath: subtraction overflow'
require call.value - (feePercent * call.value / 100 * 10^6)
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_0 = caller
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_256 = call.value
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_512 = 1
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_520 = 0
log 0xcb15aeed: Mask(128, 128, _param2), call.value, 1, _param1, _param3
call _param1 with:
value call.value - (feePercent * call.value / 100 * 10^6) wei
gas 2300 * is_zero(value) wei
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
else:
if _param5 * call.value / call.value != _param5:
revert with 0, 32, 33, 0x65536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f, mem[325 len 31]
if _param5 * call.value / 100 * 10^6 > call.value - (feePercent * call.value / 100 * 10^6):
revert with 0, 'SafeMath: subtraction overflow'
require call.value - (feePercent * call.value / 100 * 10^6) - (_param5 * call.value / 100 * 10^6)
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_0 = caller
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_256 = call.value
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_512 = 1
unknown3c57e809[addr(_param1)][Mask(128, 128, _param2)][_param3].field_520 = 0
log 0xcb15aeed: Mask(128, 128, _param2), call.value, 1, _param1, _param3
if not _param5 * call.value / 100 * 10^6:
call _param1 with:
value call.value - (feePercent * call.value / 100 * 10^6) - (_param5 * call.value / 100 * 10^6) wei
gas 2300 * is_zero(value) wei
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
else:
call _param4 with:
value _param5 * call.value / 100 * 10^6 wei
gas 2300 * is_zero(value) wei
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
call _param1 with:
value call.value - (feePercent * call.value / 100 * 10^6) - (_param5 * call.value / 100 * 10^6) wei
gas 2300 * is_zero(value) wei
stor2 = 1
def unknownf916c886(addr _param1, addr _param2, uint128 _param3, uint256 _param4, uint256 _param5, addr _param6, uint256 _param7): # not payable
require calldata.size - 4 >= 224
if not stor2:
revert with 0, 32, 31, 0xfe5265656e7472616e637947756172643a207265656e7472616e742063616c6c
stor2 = 0
require not finalized
require _param1
require _param2
require _param4
require _param5
require not unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_256
require ext_code.size(_param1)
static call _param1.allowance(address owner, address spender) with:
gas gas_remaining wei
args caller, this.address
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 >= _param5
if not _param5:
if 0 > _param5:
revert with 0, 'SafeMath: subtraction overflow'
require _param5
if not _param6:
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_0 = caller
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_256 = _param5
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_512 = _param1
log 0xcb15aeed: Mask(128, 128, _param3), _param5, _param1, _param2, _param4
require ext_code.size(_param1)
static call _param1.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(_param1)
call _param1.transferFrom(address from, address to, uint256 value) with:
gas gas_remaining wei
args caller, feeAccountToken, 0
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(_param1)
static call _param1.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[437 len 15]
require ext_code.size(_param1)
call _param1.transferFrom(address from, address to, uint256 value) with:
gas gas_remaining wei
args caller, addr(_param2), _param5
else:
if _param7 <= 0:
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_0 = caller
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_256 = _param5
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_512 = _param1
log 0xcb15aeed: Mask(128, 128, _param3), _param5, _param1, _param2, _param4
require ext_code.size(_param1)
static call _param1.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(_param1)
call _param1.transferFrom(address from, address to, uint256 value) with:
gas gas_remaining wei
args caller, feeAccountToken, 0
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(_param1)
static call _param1.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[437 len 15]
require ext_code.size(_param1)
call _param1.transferFrom(address from, address to, uint256 value) with:
gas gas_remaining wei
args caller, addr(_param2), _param5
else:
require _param7 < 100 * 10^6
if not _param5:
if 0 > _param5:
revert with 0, 'SafeMath: subtraction overflow'
require _param5
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_0 = caller
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_256 = _param5
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_512 = _param1
log 0xcb15aeed: Mask(128, 128, _param3), _param5, _param1, _param2, _param4
require ext_code.size(_param1)
static call _param1.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(_param1)
call _param1.transferFrom(address from, address to, uint256 value) with:
gas gas_remaining wei
args caller, feeAccountToken, 0
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(_param1)
static call _param1.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[565 len 15]
require ext_code.size(_param1)
call _param1.transferFrom(address from, address to, uint256 value) with:
gas gas_remaining wei
args caller, addr(_param2), _param5
else:
if _param7 * _param5 / _param5 != _param7:
revert with 0, 32, 33, 0x65536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f, mem[325 len 31]
if _param7 * _param5 / 100 * 10^6 > _param5:
revert with 0, 'SafeMath: subtraction overflow'
require _param5 - (_param7 * _param5 / 100 * 10^6)
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_0 = caller
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_256 = _param5
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_512 = _param1
log 0xcb15aeed: Mask(128, 128, _param3), _param5, _param1, _param2, _param4
require ext_code.size(_param1)
static call _param1.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(_param1)
call _param1.transferFrom(address from, address to, uint256 value) with:
gas gas_remaining wei
args caller, feeAccountToken, 0
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(_param1)
static call _param1.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[565 len 15]
require ext_code.size(_param1)
if _param7 * _param5 / 100 * 10^6:
call _param1.transferFrom(address from, address to, uint256 value) with:
gas gas_remaining wei
args caller, addr(_param6), _param7 * _param5 / 100 * 10^6
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
call _param1.transferFrom(address from, address to, uint256 value) with:
gas gas_remaining wei
args caller, addr(_param2), _param5 - (_param7 * _param5 / 100 * 10^6)
else:
if feePercent * _param5 / _param5 != feePercent:
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000,
32,
33,
0x65536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f,
mem[197 len 31]
if feePercent * _param5 / 100 * 10^6 > _param5:
revert with 0, 'SafeMath: subtraction overflow'
require _param5 - (feePercent * _param5 / 100 * 10^6)
if not _param6:
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_0 = caller
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_256 = _param5
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_512 = _param1
log 0xcb15aeed: Mask(128, 128, _param3), _param5, _param1, _param2, _param4
require ext_code.size(_param1)
static call _param1.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(_param1)
call _param1.transferFrom(address from, address to, uint256 value) with:
gas gas_remaining wei
args caller, feeAccountToken, feePercent * _param5 / 100 * 10^6
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(_param1)
static call _param1.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if (feePercent * _param5 / 100 * 10^6) + ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if (feePercent * _param5 / 100 * 10^6) + ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[437 len 15]
require ext_code.size(_param1)
call _param1.transferFrom(address from, address to, uint256 value) with:
gas gas_remaining wei
args caller, addr(_param2), _param5 - (feePercent * _param5 / 100 * 10^6)
else:
if _param7 <= 0:
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_0 = caller
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_256 = _param5
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_512 = _param1
log 0xcb15aeed: Mask(128, 128, _param3), _param5, _param1, _param2, _param4
require ext_code.size(_param1)
static call _param1.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(_param1)
call _param1.transferFrom(address from, address to, uint256 value) with:
gas gas_remaining wei
args caller, feeAccountToken, feePercent * _param5 / 100 * 10^6
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(_param1)
static call _param1.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if (feePercent * _param5 / 100 * 10^6) + ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if (feePercent * _param5 / 100 * 10^6) + ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[437 len 15]
require ext_code.size(_param1)
call _param1.transferFrom(address from, address to, uint256 value) with:
gas gas_remaining wei
args caller, addr(_param2), _param5 - (feePercent * _param5 / 100 * 10^6)
else:
require _param7 < 100 * 10^6
if not _param5:
if 0 > _param5 - (feePercent * _param5 / 100 * 10^6):
revert with 0, 'SafeMath: subtraction overflow'
require _param5 - (feePercent * _param5 / 100 * 10^6)
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_0 = caller
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_256 = _param5
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_512 = _param1
log 0xcb15aeed: Mask(128, 128, _param3), _param5, _param1, _param2, _param4
require ext_code.size(_param1)
static call _param1.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(_param1)
call _param1.transferFrom(address from, address to, uint256 value) with:
gas gas_remaining wei
args caller, feeAccountToken, feePercent * _param5 / 100 * 10^6
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(_param1)
static call _param1.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if (feePercent * _param5 / 100 * 10^6) + ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if (feePercent * _param5 / 100 * 10^6) + ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[565 len 15]
require ext_code.size(_param1)
call _param1.transferFrom(address from, address to, uint256 value) with:
gas gas_remaining wei
args caller, addr(_param2), _param5 - (feePercent * _param5 / 100 * 10^6)
else:
if _param7 * _param5 / _param5 != _param7:
revert with 0, 32, 33, 0x65536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f, mem[325 len 31]
if _param7 * _param5 / 100 * 10^6 > _param5 - (feePercent * _param5 / 100 * 10^6):
revert with 0, 'SafeMath: subtraction overflow'
require _param5 - (feePercent * _param5 / 100 * 10^6) - (_param7 * _param5 / 100 * 10^6)
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_0 = caller
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_256 = _param5
unknown3c57e809[addr(_param2)][Mask(128, 128, _param3)][_param4].field_512 = _param1
log 0xcb15aeed: Mask(128, 128, _param3), _param5, _param1, _param2, _param4
require ext_code.size(_param1)
static call _param1.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(_param1)
call _param1.transferFrom(address from, address to, uint256 value) with:
gas gas_remaining wei
args caller, feeAccountToken, feePercent * _param5 / 100 * 10^6
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(_param1)
static call _param1.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if (feePercent * _param5 / 100 * 10^6) + ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if (feePercent * _param5 / 100 * 10^6) + ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[565 len 15]
require ext_code.size(_param1)
if _param7 * _param5 / 100 * 10^6:
call _param1.transferFrom(address from, address to, uint256 value) with:
gas gas_remaining wei
args caller, addr(_param6), _param7 * _param5 / 100 * 10^6
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
call _param1.transferFrom(address from, address to, uint256 value) with:
gas gas_remaining wei
args caller, addr(_param2), _param5 - (feePercent * _param5 / 100 * 10^6) - (_param7 * _param5 / 100 * 10^6)
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
stor2 = 1
def tokenFallback(address _from, uint256 _value, bytes _data): # not payable
require calldata.size - 4 >= 96
require _data <= 4294967296
require _data + 36 <= calldata.size
require _data.length <= 4294967296 and _data + _data.length + 36 <= calldata.size
mem[128 len _data.length] = _data[all]
mem[_data.length + 128] = 0
if not stor2:
revert with 0, 32, 31, 0xfe5265656e7472616e637947756172643a207265656e7472616e742063616c6c
stor2 = 0
_6 = mem[128]
mem[ceil32(_data.length) + 128 len 56] = 0x73706179546f6b656e56415f46616b6528616464726573732c627974657331362c75696e743235362c616464726573732c75696e74323536
if Mask(32, 224, sha3(Mask(8 * -ceil32(_data.length) + _data.length + 32, 0, 0), Mask(8 * -_data.length + ceil32(_data.length) + 24, 0, 0x73706179546f6b656e56415f46616b6528616464726573732c627974657331362c75696e743235362c616464726573732c75696e74323536))) != Mask(32, 224, _6):
mem[ceil32(_data.length) + 128 len 39] = 0x29706179546f6b656e415f46616b6528616464726573732c627974657331362c75696e74323536
if Mask(32, 224, sha3(Mask(8 * -ceil32(_data.length) + _data.length + 32, 0, 0), Mask(8 * -_data.length + ceil32(_data.length) + 7, 0, 0x29706179546f6b656e415f46616b6528616464726573732c627974657331362c75696e74323536))) != Mask(32, 224, _6):
revert with 0, 'Unknown method call requested'
if _data.length != 128:
revert with 0,
32,
36,
0x74496e76616c696420696e70757420666f7220706179546f6b656e412066756e6374696f,
mem[ceil32(_data.length) + 232 len 28]
require not finalized
require caller
require mem[172 len 20]
require mem[224]
require _value
require not unknown3c57e809[mem[172 len 20]][Mask(128, 128, mem[192])][mem[224]].field_256
if not _value:
if 0 > _value:
revert with 0, 'SafeMath: subtraction overflow'
require _value
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_0 = caller
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_256 = _value
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_512 = caller
log 0xcb15aeed: Mask(128, 128, mememem
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args feeAccountToken, 0
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[ceil32(_data.length) + 469 len 15]
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args addr(mem[160]), _value
else:
if feePercent * _value / _value != feePercent:
revert with 0, 32, 33, 0x65536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f, mem[ceil32(_data.length) + 229 len 31]
if feePercent * _value / 100 * 10^6 > _value:
revert with 0, 'SafeMath: subtraction overflow'
require _value - (feePercent * _value / 100 * 10^6)
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_0 = caller
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_256 = _value
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_512 = caller
log 0xcb15aeed: Mask(128, 128, mememem
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args feeAccountToken, feePercent * _value / 100 * 10^6
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if (feePercent * _value / 100 * 10^6) + ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if (feePercent * _value / 100 * 10^6) + ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[ceil32(_data.length) + 469 len 15]
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args addr(mem[160]), _value - (feePercent * _value / 100 * 10^6)
else:
if _data.length != 192:
revert with 0,
32,
37,
0x29496e76616c696420696e70757420666f7220706179546f6b656e56412066756e6374696f,
mem[ceil32(_data.length) + 233 len 27]
require not finalized
require caller
require mem[172 len 20]
require mem[224]
require _value
require not unknown3c57e809[mem[172 len 20]][Mask(128, 128, mem[192])][mem[224]].field_256
if not _value:
if 0 > _value:
revert with 0, 'SafeMath: subtraction overflow'
require _value
if not mem[268 len 20]:
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_0 = caller
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_256 = _value
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_512 = caller
log 0xcb15aeed: Mask(128, 128, mememem
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args feeAccountToken, 0
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[ceil32(_data.length) + 469 len 15]
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args addr(mem[160]), _value
else:
if mem[288] <= 0:
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_0 = caller
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_256 = _value
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_512 = caller
log 0xcb15aeed: Mask(128, 128, mememem
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args feeAccountToken, 0
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[ceil32(_data.length) + 469 len 15]
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args addr(mem[160]), _value
else:
require mem[288] < 100 * 10^6
if not _value:
if 0 > _value:
revert with 0, 'SafeMath: subtraction overflow'
require _value
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_0 = caller
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_256 = _value
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_512 = caller
log 0xcb15aeed: Mask(128, 128, mememem
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args feeAccountToken, 0
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[ceil32(_data.length) + 597 len 15]
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args addr(mem[160]), _value
else:
if mem[288] * _value / _value != mem[288]:
revert with 0, 32, 33, 0x65536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f, mem[ceil32(_data.length) + 357 len 31]
if mem[288] * _value / 100 * 10^6 > _value:
revert with 0, 'SafeMath: subtraction overflow'
require _value - (mem[288] * _value / 100 * 10^6)
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_0 = caller
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_256 = _value
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_512 = caller
log 0xcb15aeed: Mask(128, 128, mememem
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args feeAccountToken, 0
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[ceil32(_data.length) + 597 len 15]
require ext_code.size(caller)
if mem[288] * _value / 100 * 10^6:
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args addr(mem[256]), mem[288] * _value / 100 * 10^6
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args addr(mem[160]), _value - (mem[288] * _value / 100 * 10^6)
else:
if feePercent * _value / _value != feePercent:
revert with 0, 32, 33, 0x65536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f, mem[ceil32(_data.length) + 229 len 31]
if feePercent * _value / 100 * 10^6 > _value:
revert with 0, 'SafeMath: subtraction overflow'
require _value - (feePercent * _value / 100 * 10^6)
if not mem[268 len 20]:
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_0 = caller
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_256 = _value
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_512 = caller
log 0xcb15aeed: Mask(128, 128, mememem
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args feeAccountToken, feePercent * _value / 100 * 10^6
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if (feePercent * _value / 100 * 10^6) + ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if (feePercent * _value / 100 * 10^6) + ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[ceil32(_data.length) + 469 len 15]
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args addr(mem[160]), _value - (feePercent * _value / 100 * 10^6)
else:
if mem[288] <= 0:
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_0 = caller
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_256 = _value
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_512 = caller
log 0xcb15aeed: Mask(128, 128, mememem
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args feeAccountToken, feePercent * _value / 100 * 10^6
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if (feePercent * _value / 100 * 10^6) + ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if (feePercent * _value / 100 * 10^6) + ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[ceil32(_data.length) + 469 len 15]
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args addr(mem[160]), _value - (feePercent * _value / 100 * 10^6)
else:
require mem[288] < 100 * 10^6
if not _value:
if 0 > _value - (feePercent * _value / 100 * 10^6):
revert with 0, 'SafeMath: subtraction overflow'
require _value - (feePercent * _value / 100 * 10^6)
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_0 = caller
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_256 = _value
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_512 = caller
log 0xcb15aeed: Mask(128, 128, mememem
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args feeAccountToken, feePercent * _value / 100 * 10^6
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if (feePercent * _value / 100 * 10^6) + ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if (feePercent * _value / 100 * 10^6) + ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[ceil32(_data.length) + 597 len 15]
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args addr(mem[160]), _value - (feePercent * _value / 100 * 10^6)
else:
if mem[288] * _value / _value != mem[288]:
revert with 0, 32, 33, 0x65536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f, mem[ceil32(_data.length) + 357 len 31]
if mem[288] * _value / 100 * 10^6 > _value - (feePercent * _value / 100 * 10^6):
revert with 0, 'SafeMath: subtraction overflow'
require _value - (feePercent * _value / 100 * 10^6) - (mem[288] * _value / 100 * 10^6)
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_0 = caller
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_256 = _value
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_512 = caller
log 0xcb15aeed: Mask(128, 128, mememem
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args feeAccountToken, feePercent * _value / 100 * 10^6
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if (feePercent * _value / 100 * 10^6) + ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if (feePercent * _value / 100 * 10^6) + ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[ceil32(_data.length) + 597 len 15]
require ext_code.size(caller)
if mem[288] * _value / 100 * 10^6:
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args addr(mem[256]), mem[288] * _value / 100 * 10^6
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args addr(mem[160]), _value - (feePercent * _value / 100 * 10^6) - (mem[288] * _value / 100 * 10^6)
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
stor2 = 1
def tokensReceived(address _operator, address _from, address _to, uint256 _amount, bytes _userData, bytes _operatorData): # not payable
require calldata.size - 4 >= 192
require _userData <= 4294967296
require _userData + 36 <= calldata.size
require _userData.length <= 4294967296 and _userData + _userData.length + 36 <= calldata.size
mem[128 len _userData.length] = _userData[all]
mem[_userData.length + 128] = 0
require _operatorData <= 4294967296
require _operatorData + 36 <= calldata.size
require _operatorData.length <= 4294967296 and _operatorData + _operatorData.length + 36 <= calldata.size
mem[ceil32(_userData.length) + 128] = _operatorData.length
mem[ceil32(_userData.length) + 160 len _operatorData.length] = _operatorData[all]
mem[ceil32(_userData.length) + _operatorData.length + 160] = 0
if not stor2:
revert with 0, 32, 31, 0xfe5265656e7472616e637947756172643a207265656e7472616e742063616c6c
stor2 = 0
mem[ceil32(_userData.length) + ceil32(_operatorData.length) + 160 len 56] = 0x73706179546f6b656e56415f46616b6528616464726573732c627974657331362c75696e743235362c616464726573732c75696e74323536
if Mask(32, 224, sha3(Mask(8 * -ceil32(_operatorData.length) + _operatorData.length + 32, 0, 0), Mask(8 * -_operatorData.length + ceil32(_operatorData.length) + 24, 0, 0x73706179546f6b656e56415f46616b6528616464726573732c627974657331362c75696e743235362c616464726573732c75696e74323536))) != Mask(32, 224, mem[128]):
mem[ceil32(_userData.length) + ceil32(_operatorData.length) + 160 len 39] = 0x29706179546f6b656e415f46616b6528616464726573732c627974657331362c75696e74323536
if Mask(32, 224, sha3(Mask(8 * -ceil32(_operatorData.length) + _operatorData.length + 32, 0, 0), Mask(8 * -_operatorData.length + ceil32(_operatorData.length) + 7, 0, 0x29706179546f6b656e415f46616b6528616464726573732c627974657331362c75696e74323536))) != Mask(32, 224, mem[128]):
revert with 0, 'Unknown method call requested'
if _userData.length != 128:
revert with 0,
32,
36,
0x74496e76616c696420696e70757420666f7220706179546f6b656e412066756e6374696f,
mem[ceil32(_userData.length) + ceil32(_operatorData.length) + 264 len 28]
require not finalized
require caller
require mem[172 len 20]
require mem[224]
require _amount
require not unknown3c57e809[mem[172 len 20]][Mask(128, 128, mem[192])][mem[224]].field_256
if not _amount:
if 0 > _amount:
revert with 0, 'SafeMath: subtraction overflow'
require _amount
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_0 = caller
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_256 = _amount
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_512 = caller
log 0xcb15aeed: Mask(128, 128, memount, caller, memem
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args feeAccountToken, 0
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[ceil32(_userData.length) + ceil32(_operatorData.length) + 501 len 15]
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args addr(mem[160]), _amount
else:
if feePercent * _amount / _amount != feePercent:
revert with 0,
32,
33,
0x65536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f,
mem[ceil32(_userData.length) + ceil32(_operatorData.length) + 261 len 31]
if feePercent * _amount / 100 * 10^6 > _amount:
revert with 0, 'SafeMath: subtraction overflow'
require _amount - (feePercent * _amount / 100 * 10^6)
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_0 = caller
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_256 = _amount
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_512 = caller
log 0xcb15aeed: Mask(128, 128, memount, caller, memem
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args feeAccountToken, feePercent * _amount / 100 * 10^6
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if (feePercent * _amount / 100 * 10^6) + ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if (feePercent * _amount / 100 * 10^6) + ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[ceil32(_userData.length) + ceil32(_operatorData.length) + 501 len 15]
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args addr(mem[160]), _amount - (feePercent * _amount / 100 * 10^6)
else:
if _userData.length != 192:
revert with 0,
32,
37,
0x29496e76616c696420696e70757420666f7220706179546f6b656e56412066756e6374696f,
mem[ceil32(_userData.length) + ceil32(_operatorData.length) + 265 len 27]
require not finalized
require caller
require mem[172 len 20]
require mem[224]
require _amount
require not unknown3c57e809[mem[172 len 20]][Mask(128, 128, mem[192])][mem[224]].field_256
if not _amount:
if 0 > _amount:
revert with 0, 'SafeMath: subtraction overflow'
require _amount
if not mem[268 len 20]:
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_0 = caller
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_256 = _amount
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_512 = caller
log 0xcb15aeed: Mask(128, 128, memount, caller, memem
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args feeAccountToken, 0
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[ceil32(_userData.length) + ceil32(_operatorData.length) + 501 len 15]
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args addr(mem[160]), _amount
else:
if mem[288] <= 0:
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_0 = caller
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_256 = _amount
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_512 = caller
log 0xcb15aeed: Mask(128, 128, memount, caller, memem
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args feeAccountToken, 0
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[ceil32(_userData.length) + ceil32(_operatorData.length) + 501 len 15]
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args addr(mem[160]), _amount
else:
require mem[288] < 100 * 10^6
if not _amount:
if 0 > _amount:
revert with 0, 'SafeMath: subtraction overflow'
require _amount
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_0 = caller
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_256 = _amount
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_512 = caller
log 0xcb15aeed: Mask(128, 128, memount, caller, memem
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args feeAccountToken, 0
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[ceil32(_userData.length) + ceil32(_operatorData.length) + 629 len 15]
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args addr(mem[160]), _amount
else:
if mem[288] * _amount / _amount != mem[288]:
revert with 0,
32,
33,
0x65536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f,
mem[ceil32(_userData.length) + ceil32(_operatorData.length) + 389 len 31]
if mem[288] * _amount / 100 * 10^6 > _amount:
revert with 0, 'SafeMath: subtraction overflow'
require _amount - (mem[288] * _amount / 100 * 10^6)
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_0 = caller
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_256 = _amount
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_512 = caller
log 0xcb15aeed: Mask(128, 128, memount, caller, memem
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args feeAccountToken, 0
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[ceil32(_userData.length) + ceil32(_operatorData.length) + 629 len 15]
require ext_code.size(caller)
if mem[288] * _amount / 100 * 10^6:
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args addr(mem[256]), mem[288] * _amount / 100 * 10^6
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args addr(mem[160]), _amount - (mem[288] * _amount / 100 * 10^6)
else:
if feePercent * _amount / _amount != feePercent:
revert with 0,
32,
33,
0x65536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f,
mem[ceil32(_userData.length) + ceil32(_operatorData.length) + 261 len 31]
if feePercent * _amount / 100 * 10^6 > _amount:
revert with 0, 'SafeMath: subtraction overflow'
require _amount - (feePercent * _amount / 100 * 10^6)
if not mem[268 len 20]:
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_0 = caller
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_256 = _amount
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_512 = caller
log 0xcb15aeed: Mask(128, 128, memount, caller, memem
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args feeAccountToken, feePercent * _amount / 100 * 10^6
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if (feePercent * _amount / 100 * 10^6) + ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if (feePercent * _amount / 100 * 10^6) + ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[ceil32(_userData.length) + ceil32(_operatorData.length) + 501 len 15]
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args addr(mem[160]), _amount - (feePercent * _amount / 100 * 10^6)
else:
if mem[288] <= 0:
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_0 = caller
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_256 = _amount
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_512 = caller
log 0xcb15aeed: Mask(128, 128, memount, caller, memem
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args feeAccountToken, feePercent * _amount / 100 * 10^6
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if (feePercent * _amount / 100 * 10^6) + ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if (feePercent * _amount / 100 * 10^6) + ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[ceil32(_userData.length) + ceil32(_operatorData.length) + 501 len 15]
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args addr(mem[160]), _amount - (feePercent * _amount / 100 * 10^6)
else:
require mem[288] < 100 * 10^6
if not _amount:
if 0 > _amount - (feePercent * _amount / 100 * 10^6):
revert with 0, 'SafeMath: subtraction overflow'
require _amount - (feePercent * _amount / 100 * 10^6)
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_0 = caller
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_256 = _amount
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_512 = caller
log 0xcb15aeed: Mask(128, 128, memount, caller, memem
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args feeAccountToken, feePercent * _amount / 100 * 10^6
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if (feePercent * _amount / 100 * 10^6) + ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if (feePercent * _amount / 100 * 10^6) + ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[ceil32(_userData.length) + ceil32(_operatorData.length) + 629 len 15]
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args addr(mem[160]), _amount - (feePercent * _amount / 100 * 10^6)
else:
if mem[288] * _amount / _amount != mem[288]:
revert with 0,
32,
33,
0x65536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f,
mem[ceil32(_userData.length) + ceil32(_operatorData.length) + 389 len 31]
if mem[288] * _amount / 100 * 10^6 > _amount - (feePercent * _amount / 100 * 10^6):
revert with 0, 'SafeMath: subtraction overflow'
require _amount - (feePercent * _amount / 100 * 10^6) - (mem[288] * _amount / 100 * 10^6)
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_0 = caller
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_256 = _amount
unknown3c57e809[addr(mem[160])][Mask(128, 128, mem[192])][mem[224]].field_512 = caller
log 0xcb15aeed: Mask(128, 128, memount, caller, memem
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args feeAccountToken, feePercent * _amount / 100 * 10^6
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
require ext_code.size(caller)
static call caller.balanceOf(address owner) with:
gas gas_remaining wei
args feeAccountToken
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
if (feePercent * _amount / 100 * 10^6) + ext_call.return_data < ext_call.return_data[0]:
revert with 0, 'SafeMath: addition overflow'
if (feePercent * _amount / 100 * 10^6) + ext_call.return_data > ext_call.return_data[0]:
revert with 0,
32,
49,
0x73466565207472616e7366657220746f206665654163636f756e74546f6b656e2073686f756c6420626520636f72726563,
mem[ceil32(_userData.length) + ceil32(_operatorData.length) + 629 len 15]
require ext_code.size(caller)
if mem[288] * _amount / 100 * 10^6:
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args addr(mem[256]), mem[288] * _amount / 100 * 10^6
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
call caller.transfer(address to, uint256 value) with:
gas gas_remaining wei
args addr(mem[160]), _amount - (feePercent * _amount / 100 * 10^6) - (mem[288] * _amount / 100 * 10^6)
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >= 32
stor2 = 1
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment