Skip to content

Instantly share code, notes, and snippets.

@cyborgshead

cyborgshead/gist:a07e5be3a6658d8377945ae0a71e0ade

Created August 29, 2024 15:23
Show Gist options
  • Save cyborgshead/a07e5be3a6658d8377945ae0a71e0ade to your computer and use it in GitHub Desktop.
Save cyborgshead/a07e5be3a6658d8377945ae0a71e0ade to your computer and use it in GitHub Desktop.
Download ZIP
foam-presence-claim-decompiled-bytecode
Raw
gistfile1.txt
# Palkeoramix decompiler.
def storage:
owner is addr at storage 0
stor1 is array of struct at storage 1
stor2 is array of struct at storage 2
ownerOf is mapping of struct at storage 3
balanceOf is mapping of uint256 at storage 4
approved is mapping of addr at storage 5
stor6 is mapping of uint8 at storage 6
stor7 is addr at storage 7
unknownd598215bAddress is addr at storage 8
stor8 is uint256 at storage 8
stor9 is array of struct at storage 9
stor10 is array of struct at storage 10
unknown660c4af3Address is addr at storage 11
unknownf40e73c9Address is addr at storage 12
def getApproved(uint256 _tokenId) payable:
require calldata.size - 4 >=′ 32
if 1 == addr(ownerOf[_tokenId].field_0):
revert with 0, 'ERC721: invalid token ID'
if not addr(ownerOf[_tokenId].field_0):
revert with 0, 'ERC721: invalid token ID'
return approved[_tokenId]
def ownerOf(uint256 _tokenId) payable:
require calldata.size - 4 >=′ 32
if not addr(ownerOf[_tokenId].field_0):
revert with 0, 'ERC721: invalid token ID'
if not addr(ownerOf[_tokenId].field_0) - 1:
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'PresenceClaim: ownerOf: invalid token ID'
return addr(ownerOf[_tokenId].field_0)
def unknown660c4af3() payable:
return unknown660c4af3Address
def balanceOf(address _owner) payable:
require calldata.size - 4 >=′ 32
require _owner == _owner
if not _owner:
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'ERC721: address zero is not a valid owner'
return balanceOf[addr(_owner)]
def owner() payable:
return owner
def unknownd598215b() payable:
return addr(unknownd598215bAddress)
def isApprovedForAll(address _owner, address _operator) payable:
require calldata.size - 4 >=′ 64
require _owner == _owner
require _operator == _operator
return bool(stor6[addr(_owner)][addr(_operator)])
def unknownf40e73c9() payable:
return unknownf40e73c9Address
#
# Regular functions
#
def _fallback() payable: # default function
revert
def renounceOwnership() payable:
if owner != caller:
revert with 0, 'Ownable: caller is not the owner'
owner = 0
log OwnershipTransferred(
address previousOwner=owner,
address newOwner=0)
def unknownf1efe24c(uint256 _param1) payable:
require calldata.size - 4 >=′ 32
require _param1 == addr(_param1)
if owner != caller:
revert with 0, 'Ownable: caller is not the owner'
addr(unknownd598215bAddress) = addr(_param1)
def transferOwnership(address _newOwner) payable:
require calldata.size - 4 >=′ 32
require _newOwner == _newOwner
if owner != caller:
revert with 0, 'Ownable: caller is not the owner'
if not _newOwner:
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'Ownable: new owner is the zero address'
owner = _newOwner
log OwnershipTransferred(
address previousOwner=owner,
address newOwner=_newOwner)
def supportsInterface(bytes4 _interfaceId) payable:
require calldata.size - 4 >=′ 32
require _interfaceId == Mask(32, 224, _interfaceId)
if 0x80ac58cd00000000000000000000000000000000000000000000000000000000 == Mask(32, 224, _interfaceId):
return True
if 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == Mask(32, 224, _interfaceId):
return True
return (Mask(32, 224, _interfaceId) == 0x1ffc9a700000000000000000000000000000000000000000000000000000000)
def setApprovalForAll(address _to, bool _approved) payable:
require calldata.size - 4 >=′ 64
require _to == _to
require _approved == _approved
if not caller - _to:
revert with 0, 'ERC721: approve to caller'
stor6[caller][addr(_to)] = uint8(_approved)
log ApprovalForAll(
address owner=_approved,
address operator=caller,
bool approved=_to)
def approve(address _spender, uint256 _value) payable:
require calldata.size - 4 >=′ 64
require _spender == _spender
if not addr(ownerOf[_value].field_0):
revert with 0, 'ERC721: invalid token ID'
if not _spender - addr(ownerOf[_value].field_0):
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'ERC721: approval to current owner'
if addr(ownerOf[_value].field_0) != caller:
if not stor6[addr(stor3[_value].field_0)][caller]:
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000,
'ERC721: approve caller is not token owner or approved for all'
approved[_value] = _spender
if not addr(ownerOf[_value].field_0):
revert with 0, 'ERC721: invalid token ID'
log Approval(
address tokenOwner=addr(ownerOf[_value].field_0),
address spender=_spender,
uint256 tokens=_value)
def transferFrom(address _from, address _to, uint256 _value) payable:
require calldata.size - 4 >=′ 96
require _from == _from
require _to == _to
if not addr(ownerOf[_value].field_0):
revert with 0, 'ERC721: invalid token ID'
if addr(ownerOf[_value].field_0) != caller:
if not stor6[addr(stor3[_value].field_0)][caller]:
if 1 == addr(ownerOf[_value].field_0):
revert with 0, 'ERC721: invalid token ID'
if not addr(ownerOf[_value].field_0):
revert with 0, 'ERC721: invalid token ID'
if approved[_value] != caller:
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'ERC721: caller is not token owner or approved'
if not addr(ownerOf[_value].field_0):
revert with 0, 'ERC721: invalid token ID'
if addr(ownerOf[_value].field_0) != _from:
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'ERC721: transfer from incorrect owner'
if not _to:
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'ERC721: transfer to the zero address'
if not addr(ownerOf[_value].field_0):
revert with 0, 'ERC721: invalid token ID'
if addr(ownerOf[_value].field_0) != _from:
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'ERC721: transfer from incorrect owner'
approved[_value] = 0
balanceOf[addr(_from)]--
balanceOf[_to]++
addr(ownerOf[_value].field_0) = _to
log Transfer(
address from=_from,
address to=_to,
uint256 tokens=_value)
def safeTransferFrom(address _from, address _to, uint256 _tokenId) payable:
require calldata.size - 4 >=′ 96
require _from == _from
require _to == _to
if not addr(ownerOf[_tokenId].field_0):
revert with 0, 'ERC721: invalid token ID'
if addr(ownerOf[_tokenId].field_0) != caller:
if not stor6[addr(stor3[_tokenId].field_0)][caller]:
if 1 == addr(ownerOf[_tokenId].field_0):
revert with 0, 'ERC721: invalid token ID'
if not addr(ownerOf[_tokenId].field_0):
revert with 0, 'ERC721: invalid token ID'
if approved[_tokenId] != caller:
revert with 0, 'ERC721: caller is not token owner or approved'
if not addr(ownerOf[_tokenId].field_0):
revert with 0, 'ERC721: invalid token ID'
if addr(ownerOf[_tokenId].field_0) != _from:
revert with 0, 'ERC721: transfer from incorrect owner'
if not _to:
revert with 0, 'ERC721: transfer to the zero address'
if not addr(ownerOf[_tokenId].field_0):
revert with 0, 'ERC721: invalid token ID'
if addr(ownerOf[_tokenId].field_0) != _from:
revert with 0, 'ERC721: transfer from incorrect owner'
approved[_tokenId] = 0
balanceOf[addr(_from)]--
balanceOf[_to]++
addr(ownerOf[_tokenId].field_0) = _to
log Transfer(
address from=_from,
address to=_to,
uint256 tokens=_tokenId)
if ext_code.size(_to):
call _to.onERC721Received(address operator, address from, uint256 childTokenId, bytes data) with:
gas gas_remaining wei
args 0, uint32(caller), addr(_from), _tokenId, 128, 0
if not ext_call.success:
if not return_data.size:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
if not -return_data.size:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >=′ 32
require ext_call.return_data == Mask(32, 224, ext_call.return_data[0])
if Mask(32, 224, ext_call.return_data[0]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
def safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes _data) payable:
require calldata.size - 4 >=′ 128
require _from == _from
require _to == _to
require _data <= 18446744073709551615
require _data + 35 <′ calldata.size
if _data.length > 18446744073709551615:
revert with 'NH{q', 65
if ceil32(ceil32(_data.length)) + 97 < 96 or ceil32(ceil32(_data.length)) + 97 > 18446744073709551615:
revert with 'NH{q', 65
require _data + _data.length + 36 <= calldata.size
if not addr(ownerOf[_tokenId].field_0):
revert with 0, 'ERC721: invalid token ID'
if addr(ownerOf[_tokenId].field_0) != caller:
if not stor6[addr(stor3[_tokenId].field_0)][caller]:
if 1 == addr(ownerOf[_tokenId].field_0):
revert with 0, 'ERC721: invalid token ID'
if not addr(ownerOf[_tokenId].field_0):
revert with 0, 'ERC721: invalid token ID'
if approved[_tokenId] != caller:
revert with 0, 'ERC721: caller is not token owner or approved'
if not addr(ownerOf[_tokenId].field_0):
revert with 0, 'ERC721: invalid token ID'
if addr(ownerOf[_tokenId].field_0) != _from:
revert with 0, 'ERC721: transfer from incorrect owner'
if not _to:
revert with 0, 'ERC721: transfer to the zero address'
if not addr(ownerOf[_tokenId].field_0):
revert with 0, 'ERC721: invalid token ID'
if addr(ownerOf[_tokenId].field_0) != _from:
revert with 0, 'ERC721: transfer from incorrect owner'
approved[_tokenId] = 0
balanceOf[addr(_from)]--
balanceOf[_to]++
addr(ownerOf[_tokenId].field_0) = _to
log Transfer(
address from=_from,
address to=_to,
uint256 tokens=_tokenId)
if ext_code.size(_to):
call _to.onERC721Received(address operator, address from, uint256 childTokenId, bytes data) with:
gas gas_remaining wei
args caller, addr(_from), _tokenId, Array(len=_data.length, data=_data[all])
if not ext_call.success:
if not return_data.size:
if not -_data.length:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with _data[all]
if not -return_data.size:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >=′ 32
require ext_call.return_data == Mask(32, 224, ext_call.return_data[0])
if Mask(32, 224, ext_call.return_data[0]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
def unknown87121759(uint256 _param1, uint256 _param2, uint256 _param3) payable:
require calldata.size - 4 >=′ 96
require _param1 == addr(_param1)
require _param2 == addr(_param2)
if not addr(unknownd598215bAddress):
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000,
'PresenceClaim: Remote PresenceClaim was not initialized'
if not addr(_param2):
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'PresenceClaim: cannot bridge to the zero address'
if not addr(ownerOf[_param3].field_0):
revert with 0, 'ERC721: invalid token ID'
if addr(ownerOf[_param3].field_0) != caller:
if not stor6[addr(stor3[_param3].field_0)][caller]:
if 1 == addr(ownerOf[_param3].field_0):
revert with 0, 'ERC721: invalid token ID'
if not addr(ownerOf[_param3].field_0):
revert with 0, 'ERC721: invalid token ID'
if approved[_param3] != caller:
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'PresenceClaim: Bridging is basically a transfer'
if not addr(ownerOf[_param3].field_0):
revert with 0, 'ERC721: invalid token ID'
if not addr(ownerOf[_param3].field_0) - 1:
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'PresenceClaim: ownerOf: invalid token ID'
if not addr(ownerOf[_param3].field_0):
revert with 0, 'ERC721: invalid token ID'
if addr(ownerOf[_param3].field_0) != addr(ownerOf[_param3].field_0):
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'ERC721: transfer from incorrect owner'
if not addr(ownerOf[_param3].field_0):
revert with 0, 'ERC721: invalid token ID'
if addr(ownerOf[_param3].field_0) != addr(ownerOf[_param3].field_0):
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'ERC721: transfer from incorrect owner'
approved[_param3] = 0
balanceOf[addr(stor3[_param3].field_0)]--
balanceOf[1]++
uint8(ownerOf[_param3].field_0) = 1
Mask(152, 0, ownerOf[_param3].field_8) = 0
log Transfer(
address from=addr(ownerOf[_param3].field_0),
address to=1,
uint256 tokens=_param3)
require ext_code.size(stor7)
call stor7.0x3dbb202b with:
gas gas_remaining wei
args addr(unknownd598215bAddress), 96, 10^6, 100, 4019228372, addr(_param1) << 64, 0, addr(_param2), _param3, 0, Mask(192, 0, stor8) >> 544, 0
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
def unknown312f5f97(uint256 _param1, uint256 _param2) payable:
require calldata.size - 4 >=′ 64
mem[100] = _param2
static call unknownf40e73c9Address.ownerOf(uint256 deedId) with:
gas gas_remaining wei
args _param2
mem[96] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >=′ 32
require ext_call.return_data == ext_call.return_data[12 len 20]
mem[ceil32(return_data.size) + 132] = _param1
require ext_code.size(unknownf40e73c9Address)
call unknownf40e73c9Address.0x7f7499c3 with:
gas gas_remaining wei
args _param2, _param1
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
mem[ceil32(return_data.size) + 100] = _param1
static call unknown660c4af3Address.0xce6915fa with:
gas gas_remaining wei
args _param1
mem[ceil32(return_data.size) + 96] = ext_call.return_data[0]
require return_data.size >=′ 32
require ext_call.return_data == bool(ext_call.return_data[0])
if not ext_call.return_data[0]:
revert with 0, 'PresenceClaim: _safeMint: CID has not been validated!'
mem[(2 * ceil32(return_data.size)) + 96] = 0
if not addr(ext_call.return_data):
revert with 0, 'ERC721: mint to the zero address'
if addr(ownerOf[_param1].field_0) != 1:
if addr(ownerOf[_param1].field_0):
revert with 0, 'ERC721: token already minted'
if addr(ownerOf[_param1].field_0) != 1:
if addr(ownerOf[_param1].field_0):
revert with 0, 'ERC721: token already minted'
balanceOf[addr(ext_call.return_data)]++
addr(ownerOf[_param1].field_0) = addr(ext_call.return_data)
log Transfer(
address from=0,
address to=addr(ext_call.return_data
uint256 tokens=_param1)
if ext_code.size(addr(ext_call.return_data)):
mem[(2 * ceil32(return_data.size)) + 132] = caller
mem[(2 * ceil32(return_data.size)) + 164] = 0
mem[(2 * ceil32(return_data.size)) + 196] = _param1
mem[(2 * ceil32(return_data.size)) + 228] = 128
mem[(2 * ceil32(return_data.size)) + 260] = 0
mem[(2 * ceil32(return_data.size)) + 292 len 0] = None
call addr(ext_call.return_data).onERC721Received(address operator, address from, uint256 childTokenId, bytes data) with:
gas gas_remaining wei
args caller, 0, _param1, 128, 0
mem[(2 * ceil32(return_data.size)) + 128] = ext_call.return_data[0]
if not ext_call.success:
if not return_data.size:
if not -ext_call.return_data[0]:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with memory
from 128
len ext_call.return_data[0]
if not -return_data.size:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >=′ 32
require ext_call.return_data == Mask(32, 224, ext_call.return_data[0])
if Mask(32, 224, ext_call.return_data[0]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
def unknownef908ed4(uint256 _param1, uint256 _param2, uint256 _param3) payable:
require calldata.size - 4 >=′ 96
require _param1 == addr(_param1)
require _param2 == addr(_param2)
if stor7 != caller:
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000,
'PresenceClaim: receiveBridge can only be called by the Optimism CrossDomainMessenger'
static call stor7.'n)nE' with:
gas gas_remaining wei
mem[96] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >=′ 32
require ext_call.return_data == ext_call.return_data[12 len 20]
if ext_call.return_dataaddr(unknownd598215bAddress):
revert with 0, 'PresenceClaim: can only bridge from the associated contract on the other network'
mem[ceil32(return_data.size) + 100] = _param3
static call unknown660c4af3Address.0xce6915fa with:
gas gas_remaining wei
args _param3
mem[ceil32(return_data.size) + 96] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >=′ 32
require ext_call.return_data == bool(ext_call.return_data[0])
if not ext_call.return_data[0]:
revert with 0, 'PresenceClaim: _safeMint: CID has not been validated!'
mem[(2 * ceil32(return_data.size)) + 96] = 0
if not addr(_param2):
revert with 0, 'ERC721: mint to the zero address'
if addr(ownerOf[_param3].field_0) != 1:
if addr(ownerOf[_param3].field_0):
revert with 0, 'ERC721: token already minted'
if addr(ownerOf[_param3].field_0) != 1:
if addr(ownerOf[_param3].field_0):
revert with 0, 'ERC721: token already minted'
balanceOf[addr(_param2)]++
addr(ownerOf[_param3].field_0) = addr(_param2)
log Transfer(
address from=0,
address to=addr(_param2),
uint256 tokens=_param3)
if ext_code.size(addr(_param2)):
mem[(2 * ceil32(return_data.size)) + 132] = caller
mem[(2 * ceil32(return_data.size)) + 164] = 0
mem[(2 * ceil32(return_data.size)) + 196] = _param3
mem[(2 * ceil32(return_data.size)) + 228] = 128
mem[(2 * ceil32(return_data.size)) + 260] = 0
mem[(2 * ceil32(return_data.size)) + 292 len 0] = None
call addr(_param2).onERC721Received(address operator, address from, uint256 childTokenId, bytes data) with:
gas gas_remaining wei
args caller, 0, _param3, 128, 0
mem[(2 * ceil32(return_data.size)) + 128] = ext_call.return_data[0]
if not ext_call.success:
if not return_data.size:
if not -ext_call.return_data[0]:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with memory
from 128
len ext_call.return_data[0]
if not -return_data.size:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >=′ 32
require ext_call.return_data == Mask(32, 224, ext_call.return_data[0])
if Mask(32, 224, ext_call.return_data[0]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
def unknowna58598cc(uint256 _param1) payable:
require calldata.size - 4 >=′ 32
if 1 == addr(ownerOf[_param1].field_0):
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'PresenceClaim: presence claim does not exist'
mem[0] = _param1
mem[32] = 3
if not addr(ownerOf[_param1].field_0):
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'PresenceClaim: presence claim does not exist'
static call unknown660c4af3Address.0x5558f555 with:
gas gas_remaining wei
mem[96] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >=′ 32
require ext_call.return_data == ext_call.return_data[12 len 20]
mem[ceil32(return_data.size) + 96] = 0xb5f951bd00000000000000000000000000000000000000000000000000000000
mem[ceil32(return_data.size) + 100] = _param1
static call addr(ext_call.return_data).0xb5f951bd with:
gas gas_remaining wei
args _param1
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
mem[ceil32(return_data.size) + 96 len return_data.size] = ext_call.return_data[0 len return_data.size]
require return_data.size >=′ 32
_14 = mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32
require mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32 <= 18446744073709551615
require return_data.size - mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32 >=′ 320
if not bool((2 * ceil32(return_data.size)) + 416 <= 18446744073709551615):
revert with 'NH{q', 65
mem[64] = (2 * ceil32(return_data.size)) + 416
mem[(2 * ceil32(return_data.size)) + 96] = mem[ceil32(return_data.size) + mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32 + 96]
mem[(2 * ceil32(return_data.size)) + 128] = mem[ceil32(return_data.size) + _14 + 128]
require mem[ceil32(return_data.size) + _14 + 160] == mem[ceil32(return_data.size) + _14 + 180 len 12]
mem[(2 * ceil32(return_data.size)) + 160] = mem[ceil32(return_data.size) + _14 + 160]
require mem[ceil32(return_data.size) + _14 + 192] == Mask(160, 96, mem[ceil32(return_data.size) + _14 + 192])
mem[(2 * ceil32(return_data.size)) + 192] = mem[ceil32(return_data.size) + _14 + 192]
require mem[ceil32(return_data.size) + _14 + 224] == mem[ceil32(return_data.size) + _14 + 236 len 20]
mem[(2 * ceil32(return_data.size)) + 224] = mem[ceil32(return_data.size) + _14 + 224]
require mem[ceil32(return_data.size) + _14 + 256] == mem[ceil32(return_data.size) + _14 + 276 len 12]
mem[(2 * ceil32(return_data.size)) + 256] = mem[ceil32(return_data.size) + _14 + 256]
require mem[ceil32(return_data.size) + _14 + 288] == mem[ceil32(return_data.size) + _14 + 316 len 4]
mem[(2 * ceil32(return_data.size)) + 288] = mem[ceil32(return_data.size) + _14 + 288]
require mem[ceil32(return_data.size) + _14 + 320] == mem[ceil32(return_data.size) + _14 + 351 len 1]
mem[(2 * ceil32(return_data.size)) + 320] = mem[ceil32(return_data.size) + _14 + 320]
require mem[ceil32(return_data.size) + _14 + 352] == mem[ceil32(return_data.size) + _14 + 383 len 1]
mem[(2 * ceil32(return_data.size)) + 352] = mem[ceil32(return_data.size) + _14 + 352]
_25 = mem[ceil32(return_data.size) + _14 + 384]
require mem[ceil32(return_data.size) + _14 + 384] <= 18446744073709551615
require ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 127 <′ ceil32(return_data.size) + return_data.size + 96
_26 = mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96]
if mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96] > 18446744073709551615:
revert with 'NH{q', 65
if ceil32(ceil32(mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96])) + 321 < 320 or (2 * ceil32(return_data.size)) + ceil32(ceil32(mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96])) + 417 > 18446744073709551615:
revert with 'NH{q', 65
mem[64] = (2 * ceil32(return_data.size)) + ceil32(ceil32(mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96])) + 417
mem[(2 * ceil32(return_data.size)) + 416] = mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96]
require _14 + _25 + _26 + 32 <= return_data.size
mem[(2 * ceil32(return_data.size)) + 448 len ceil32(_26)] = mem[ceil32(return_data.size) + _14 + _25 + 128 len ceil32(_26)]
if ceil32(_26) > _26:
mem[_26 + (2 * ceil32(return_data.size)) + 448] = 0
mem[(2 * ceil32(return_data.size)) + 384] = (2 * ceil32(return_data.size)) + 416
mem[mem[64]] = mem[(2 * ceil32(return_data.size)) + 96]
return memory
from mem[64]
len 32
def unknownc67ae003(uint256 _param1) payable:
require calldata.size - 4 >=′ 32
if 1 == addr(ownerOf[_param1].field_0):
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'PresenceClaim: presence claim does not exist'
mem[0] = _param1
mem[32] = 3
if not addr(ownerOf[_param1].field_0):
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'PresenceClaim: presence claim does not exist'
static call unknown660c4af3Address.0x5558f555 with:
gas gas_remaining wei
mem[96] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >=′ 32
require ext_call.return_data == ext_call.return_data[12 len 20]
mem[ceil32(return_data.size) + 96] = 0xb5f951bd00000000000000000000000000000000000000000000000000000000
mem[ceil32(return_data.size) + 100] = _param1
static call addr(ext_call.return_data).0xb5f951bd with:
gas gas_remaining wei
args _param1
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
mem[ceil32(return_data.size) + 96 len return_data.size] = ext_call.return_data[0 len return_data.size]
require return_data.size >=′ 32
_14 = mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32
require mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32 <= 18446744073709551615
require return_data.size - mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32 >=′ 320
if not bool((2 * ceil32(return_data.size)) + 416 <= 18446744073709551615):
revert with 'NH{q', 65
mem[64] = (2 * ceil32(return_data.size)) + 416
mem[(2 * ceil32(return_data.size)) + 96] = mem[ceil32(return_data.size) + mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32 + 96]
mem[(2 * ceil32(return_data.size)) + 128] = mem[ceil32(return_data.size) + _14 + 128]
require mem[ceil32(return_data.size) + _14 + 160] == mem[ceil32(return_data.size) + _14 + 180 len 12]
mem[(2 * ceil32(return_data.size)) + 160] = mem[ceil32(return_data.size) + _14 + 160]
require mem[ceil32(return_data.size) + _14 + 192] == Mask(160, 96, mem[ceil32(return_data.size) + _14 + 192])
mem[(2 * ceil32(return_data.size)) + 192] = mem[ceil32(return_data.size) + _14 + 192]
require mem[ceil32(return_data.size) + _14 + 224] == mem[ceil32(return_data.size) + _14 + 236 len 20]
mem[(2 * ceil32(return_data.size)) + 224] = mem[ceil32(return_data.size) + _14 + 224]
require mem[ceil32(return_data.size) + _14 + 256] == mem[ceil32(return_data.size) + _14 + 276 len 12]
mem[(2 * ceil32(return_data.size)) + 256] = mem[ceil32(return_data.size) + _14 + 256]
require mem[ceil32(return_data.size) + _14 + 288] == mem[ceil32(return_data.size) + _14 + 316 len 4]
mem[(2 * ceil32(return_data.size)) + 288] = mem[ceil32(return_data.size) + _14 + 288]
require mem[ceil32(return_data.size) + _14 + 320] == mem[ceil32(return_data.size) + _14 + 351 len 1]
mem[(2 * ceil32(return_data.size)) + 320] = mem[ceil32(return_data.size) + _14 + 320]
require mem[ceil32(return_data.size) + _14 + 352] == mem[ceil32(return_data.size) + _14 + 383 len 1]
mem[(2 * ceil32(return_data.size)) + 352] = mem[ceil32(return_data.size) + _14 + 352]
_25 = mem[ceil32(return_data.size) + _14 + 384]
require mem[ceil32(return_data.size) + _14 + 384] <= 18446744073709551615
require ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 127 <′ ceil32(return_data.size) + return_data.size + 96
_26 = mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96]
if mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96] > 18446744073709551615:
revert with 'NH{q', 65
if ceil32(ceil32(mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96])) + 321 < 320 or (2 * ceil32(return_data.size)) + ceil32(ceil32(mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96])) + 417 > 18446744073709551615:
revert with 'NH{q', 65
mem[64] = (2 * ceil32(return_data.size)) + ceil32(ceil32(mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96])) + 417
mem[(2 * ceil32(return_data.size)) + 416] = mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96]
require _14 + _25 + _26 + 32 <= return_data.size
mem[(2 * ceil32(return_data.size)) + 448 len ceil32(_26)] = mem[ceil32(return_data.size) + _14 + _25 + 128 len ceil32(_26)]
if ceil32(_26) > _26:
mem[_26 + (2 * ceil32(return_data.size)) + 448] = 0
mem[(2 * ceil32(return_data.size)) + 384] = (2 * ceil32(return_data.size)) + 416
mem[mem[64]] = mem[(2 * ceil32(return_data.size)) + 128]
return memory
from mem[64]
len 32
def unknown7c1366a9(uint256 _param1) payable:
require calldata.size - 4 >=′ 32
if 1 == addr(ownerOf[_param1].field_0):
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'PresenceClaim: presence claim does not exist'
mem[0] = _param1
mem[32] = 3
if not addr(ownerOf[_param1].field_0):
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'PresenceClaim: presence claim does not exist'
static call unknown660c4af3Address.0x5558f555 with:
gas gas_remaining wei
mem[96] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >=′ 32
require ext_call.return_data == ext_call.return_data[12 len 20]
mem[ceil32(return_data.size) + 96] = 0xb5f951bd00000000000000000000000000000000000000000000000000000000
mem[ceil32(return_data.size) + 100] = _param1
static call addr(ext_call.return_data).0xb5f951bd with:
gas gas_remaining wei
args _param1
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
mem[ceil32(return_data.size) + 96 len return_data.size] = ext_call.return_data[0 len return_data.size]
require return_data.size >=′ 32
_14 = mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32
require mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32 <= 18446744073709551615
require return_data.size - mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32 >=′ 320
if not bool((2 * ceil32(return_data.size)) + 416 <= 18446744073709551615):
revert with 'NH{q', 65
mem[64] = (2 * ceil32(return_data.size)) + 416
mem[(2 * ceil32(return_data.size)) + 96] = mem[ceil32(return_data.size) + mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32 + 96]
mem[(2 * ceil32(return_data.size)) + 128] = mem[ceil32(return_data.size) + _14 + 128]
require mem[ceil32(return_data.size) + _14 + 160] == mem[ceil32(return_data.size) + _14 + 180 len 12]
mem[(2 * ceil32(return_data.size)) + 160] = mem[ceil32(return_data.size) + _14 + 160]
require mem[ceil32(return_data.size) + _14 + 192] == Mask(160, 96, mem[ceil32(return_data.size) + _14 + 192])
mem[(2 * ceil32(return_data.size)) + 192] = mem[ceil32(return_data.size) + _14 + 192]
require mem[ceil32(return_data.size) + _14 + 224] == mem[ceil32(return_data.size) + _14 + 236 len 20]
mem[(2 * ceil32(return_data.size)) + 224] = mem[ceil32(return_data.size) + _14 + 224]
require mem[ceil32(return_data.size) + _14 + 256] == mem[ceil32(return_data.size) + _14 + 276 len 12]
mem[(2 * ceil32(return_data.size)) + 256] = mem[ceil32(return_data.size) + _14 + 256]
require mem[ceil32(return_data.size) + _14 + 288] == mem[ceil32(return_data.size) + _14 + 316 len 4]
mem[(2 * ceil32(return_data.size)) + 288] = mem[ceil32(return_data.size) + _14 + 288]
require mem[ceil32(return_data.size) + _14 + 320] == mem[ceil32(return_data.size) + _14 + 351 len 1]
mem[(2 * ceil32(return_data.size)) + 320] = mem[ceil32(return_data.size) + _14 + 320]
require mem[ceil32(return_data.size) + _14 + 352] == mem[ceil32(return_data.size) + _14 + 383 len 1]
mem[(2 * ceil32(return_data.size)) + 352] = mem[ceil32(return_data.size) + _14 + 352]
_25 = mem[ceil32(return_data.size) + _14 + 384]
require mem[ceil32(return_data.size) + _14 + 384] <= 18446744073709551615
require ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 127 <′ ceil32(return_data.size) + return_data.size + 96
_26 = mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96]
if mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96] > 18446744073709551615:
revert with 'NH{q', 65
if ceil32(ceil32(mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96])) + 321 < 320 or (2 * ceil32(return_data.size)) + ceil32(ceil32(mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96])) + 417 > 18446744073709551615:
revert with 'NH{q', 65
mem[64] = (2 * ceil32(return_data.size)) + ceil32(ceil32(mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96])) + 417
mem[(2 * ceil32(return_data.size)) + 416] = mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96]
require _14 + _25 + _26 + 32 <= return_data.size
mem[(2 * ceil32(return_data.size)) + 448 len ceil32(_26)] = mem[ceil32(return_data.size) + _14 + _25 + 128 len ceil32(_26)]
if ceil32(_26) > _26:
mem[_26 + (2 * ceil32(return_data.size)) + 448] = 0
mem[(2 * ceil32(return_data.size)) + 384] = (2 * ceil32(return_data.size)) + 416
mem[mem[64]] = mem[(2 * ceil32(return_data.size)) + 383 len 1]
return memory
from mem[64]
len 32
def unknownc9990aa6(uint256 _param1) payable:
require calldata.size - 4 >=′ 32
if 1 == addr(ownerOf[_param1].field_0):
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'PresenceClaim: presence claim does not exist'
mem[0] = _param1
mem[32] = 3
if not addr(ownerOf[_param1].field_0):
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'PresenceClaim: presence claim does not exist'
static call unknown660c4af3Address.0x5558f555 with:
gas gas_remaining wei
mem[96] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >=′ 32
require ext_call.return_data == ext_call.return_data[12 len 20]
mem[ceil32(return_data.size) + 96] = 0xb5f951bd00000000000000000000000000000000000000000000000000000000
mem[ceil32(return_data.size) + 100] = _param1
static call addr(ext_call.return_data).0xb5f951bd with:
gas gas_remaining wei
args _param1
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
mem[ceil32(return_data.size) + 96 len return_data.size] = ext_call.return_data[0 len return_data.size]
require return_data.size >=′ 32
_14 = mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32
require mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32 <= 18446744073709551615
require return_data.size - mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32 >=′ 320
if not bool((2 * ceil32(return_data.size)) + 416 <= 18446744073709551615):
revert with 'NH{q', 65
mem[64] = (2 * ceil32(return_data.size)) + 416
mem[(2 * ceil32(return_data.size)) + 96] = mem[ceil32(return_data.size) + mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32 + 96]
mem[(2 * ceil32(return_data.size)) + 128] = mem[ceil32(return_data.size) + _14 + 128]
require mem[ceil32(return_data.size) + _14 + 160] == mem[ceil32(return_data.size) + _14 + 180 len 12]
mem[(2 * ceil32(return_data.size)) + 160] = mem[ceil32(return_data.size) + _14 + 160]
require mem[ceil32(return_data.size) + _14 + 192] == Mask(160, 96, mem[ceil32(return_data.size) + _14 + 192])
mem[(2 * ceil32(return_data.size)) + 192] = mem[ceil32(return_data.size) + _14 + 192]
require mem[ceil32(return_data.size) + _14 + 224] == mem[ceil32(return_data.size) + _14 + 236 len 20]
mem[(2 * ceil32(return_data.size)) + 224] = mem[ceil32(return_data.size) + _14 + 224]
require mem[ceil32(return_data.size) + _14 + 256] == mem[ceil32(return_data.size) + _14 + 276 len 12]
mem[(2 * ceil32(return_data.size)) + 256] = mem[ceil32(return_data.size) + _14 + 256]
require mem[ceil32(return_data.size) + _14 + 288] == mem[ceil32(return_data.size) + _14 + 316 len 4]
mem[(2 * ceil32(return_data.size)) + 288] = mem[ceil32(return_data.size) + _14 + 288]
require mem[ceil32(return_data.size) + _14 + 320] == mem[ceil32(return_data.size) + _14 + 351 len 1]
mem[(2 * ceil32(return_data.size)) + 320] = mem[ceil32(return_data.size) + _14 + 320]
require mem[ceil32(return_data.size) + _14 + 352] == mem[ceil32(return_data.size) + _14 + 383 len 1]
mem[(2 * ceil32(return_data.size)) + 352] = mem[ceil32(return_data.size) + _14 + 352]
_25 = mem[ceil32(return_data.size) + _14 + 384]
require mem[ceil32(return_data.size) + _14 + 384] <= 18446744073709551615
require ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 127 <′ ceil32(return_data.size) + return_data.size + 96
_26 = mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96]
if mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96] > 18446744073709551615:
revert with 'NH{q', 65
if ceil32(ceil32(mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96])) + 321 < 320 or (2 * ceil32(return_data.size)) + ceil32(ceil32(mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96])) + 417 > 18446744073709551615:
revert with 'NH{q', 65
mem[64] = (2 * ceil32(return_data.size)) + ceil32(ceil32(mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96])) + 417
mem[(2 * ceil32(return_data.size)) + 416] = mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96]
require _14 + _25 + _26 + 32 <= return_data.size
mem[(2 * ceil32(return_data.size)) + 448 len ceil32(_26)] = mem[ceil32(return_data.size) + _14 + _25 + 128 len ceil32(_26)]
if ceil32(_26) > _26:
mem[_26 + (2 * ceil32(return_data.size)) + 448] = 0
mem[(2 * ceil32(return_data.size)) + 384] = (2 * ceil32(return_data.size)) + 416
mem[mem[64]] = Mask(160, 96, mem[(2 * ceil32(return_data.size)) + 192])
return memory
from mem[64]
len 32
def unknown1386dc12(uint256 _param1) payable:
require calldata.size - 4 >=′ 32
if 1 == addr(ownerOf[_param1].field_0):
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'PresenceClaim: presence claim does not exist'
mem[0] = _param1
mem[32] = 3
if not addr(ownerOf[_param1].field_0):
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'PresenceClaim: presence claim does not exist'
static call unknown660c4af3Address.0x5558f555 with:
gas gas_remaining wei
mem[96] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >=′ 32
require ext_call.return_data == ext_call.return_data[12 len 20]
mem[ceil32(return_data.size) + 96] = 0xb5f951bd00000000000000000000000000000000000000000000000000000000
mem[ceil32(return_data.size) + 100] = _param1
static call addr(ext_call.return_data).0xb5f951bd with:
gas gas_remaining wei
args _param1
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
mem[ceil32(return_data.size) + 96 len return_data.size] = ext_call.return_data[0 len return_data.size]
require return_data.size >=′ 32
_14 = mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32
require mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32 <= 18446744073709551615
require return_data.size - mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32 >=′ 320
if not bool((2 * ceil32(return_data.size)) + 416 <= 18446744073709551615):
revert with 'NH{q', 65
mem[64] = (2 * ceil32(return_data.size)) + 416
mem[(2 * ceil32(return_data.size)) + 96] = mem[ceil32(return_data.size) + mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32 + 96]
mem[(2 * ceil32(return_data.size)) + 128] = mem[ceil32(return_data.size) + _14 + 128]
require mem[ceil32(return_data.size) + _14 + 160] == mem[ceil32(return_data.size) + _14 + 180 len 12]
mem[(2 * ceil32(return_data.size)) + 160] = mem[ceil32(return_data.size) + _14 + 160]
require mem[ceil32(return_data.size) + _14 + 192] == Mask(160, 96, mem[ceil32(return_data.size) + _14 + 192])
mem[(2 * ceil32(return_data.size)) + 192] = mem[ceil32(return_data.size) + _14 + 192]
require mem[ceil32(return_data.size) + _14 + 224] == mem[ceil32(return_data.size) + _14 + 236 len 20]
mem[(2 * ceil32(return_data.size)) + 224] = mem[ceil32(return_data.size) + _14 + 224]
require mem[ceil32(return_data.size) + _14 + 256] == mem[ceil32(return_data.size) + _14 + 276 len 12]
mem[(2 * ceil32(return_data.size)) + 256] = mem[ceil32(return_data.size) + _14 + 256]
require mem[ceil32(return_data.size) + _14 + 288] == mem[ceil32(return_data.size) + _14 + 316 len 4]
mem[(2 * ceil32(return_data.size)) + 288] = mem[ceil32(return_data.size) + _14 + 288]
require mem[ceil32(return_data.size) + _14 + 320] == mem[ceil32(return_data.size) + _14 + 351 len 1]
mem[(2 * ceil32(return_data.size)) + 320] = mem[ceil32(return_data.size) + _14 + 320]
require mem[ceil32(return_data.size) + _14 + 352] == mem[ceil32(return_data.size) + _14 + 383 len 1]
mem[(2 * ceil32(return_data.size)) + 352] = mem[ceil32(return_data.size) + _14 + 352]
_25 = mem[ceil32(return_data.size) + _14 + 384]
require mem[ceil32(return_data.size) + _14 + 384] <= 18446744073709551615
require ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 127 <′ ceil32(return_data.size) + return_data.size + 96
_26 = mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96]
if mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96] > 18446744073709551615:
revert with 'NH{q', 65
if ceil32(ceil32(mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96])) + 321 < 320 or (2 * ceil32(return_data.size)) + ceil32(ceil32(mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96])) + 417 > 18446744073709551615:
revert with 'NH{q', 65
mem[64] = (2 * ceil32(return_data.size)) + ceil32(ceil32(mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96])) + 417
mem[(2 * ceil32(return_data.size)) + 416] = mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96]
require _14 + _25 + _26 + 32 <= return_data.size
mem[(2 * ceil32(return_data.size)) + 448 len ceil32(_26)] = mem[ceil32(return_data.size) + _14 + _25 + 128 len ceil32(_26)]
if ceil32(_26) > _26:
mem[_26 + (2 * ceil32(return_data.size)) + 448] = 0
mem[(2 * ceil32(return_data.size)) + 384] = (2 * ceil32(return_data.size)) + 416
mem[mem[64]] = mem[(2 * ceil32(return_data.size)) + 180 len 12]
return memory
from mem[64]
len 32
def unknownb0d619d8(uint256 _param1) payable:
require calldata.size - 4 >=′ 32
if 1 == addr(ownerOf[_param1].field_0):
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'PresenceClaim: presence claim does not exist'
mem[0] = _param1
mem[32] = 3
if not addr(ownerOf[_param1].field_0):
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'PresenceClaim: presence claim does not exist'
static call unknown660c4af3Address.0x5558f555 with:
gas gas_remaining wei
mem[96] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >=′ 32
require ext_call.return_data == ext_call.return_data[12 len 20]
mem[ceil32(return_data.size) + 96] = 0xb5f951bd00000000000000000000000000000000000000000000000000000000
mem[ceil32(return_data.size) + 100] = _param1
static call addr(ext_call.return_data).0xb5f951bd with:
gas gas_remaining wei
args _param1
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
mem[ceil32(return_data.size) + 96 len return_data.size] = ext_call.return_data[0 len return_data.size]
require return_data.size >=′ 32
_14 = mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32
require mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32 <= 18446744073709551615
require return_data.size - mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32 >=′ 320
if not bool((2 * ceil32(return_data.size)) + 416 <= 18446744073709551615):
revert with 'NH{q', 65
mem[64] = (2 * ceil32(return_data.size)) + 416
mem[(2 * ceil32(return_data.size)) + 96] = mem[ceil32(return_data.size) + mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32 + 96]
mem[(2 * ceil32(return_data.size)) + 128] = mem[ceil32(return_data.size) + _14 + 128]
require mem[ceil32(return_data.size) + _14 + 160] == mem[ceil32(return_data.size) + _14 + 180 len 12]
mem[(2 * ceil32(return_data.size)) + 160] = mem[ceil32(return_data.size) + _14 + 160]
require mem[ceil32(return_data.size) + _14 + 192] == Mask(160, 96, mem[ceil32(return_data.size) + _14 + 192])
mem[(2 * ceil32(return_data.size)) + 192] = mem[ceil32(return_data.size) + _14 + 192]
require mem[ceil32(return_data.size) + _14 + 224] == mem[ceil32(return_data.size) + _14 + 236 len 20]
mem[(2 * ceil32(return_data.size)) + 224] = mem[ceil32(return_data.size) + _14 + 224]
require mem[ceil32(return_data.size) + _14 + 256] == mem[ceil32(return_data.size) + _14 + 276 len 12]
mem[(2 * ceil32(return_data.size)) + 256] = mem[ceil32(return_data.size) + _14 + 256]
require mem[ceil32(return_data.size) + _14 + 288] == mem[ceil32(return_data.size) + _14 + 316 len 4]
mem[(2 * ceil32(return_data.size)) + 288] = mem[ceil32(return_data.size) + _14 + 288]
require mem[ceil32(return_data.size) + _14 + 320] == mem[ceil32(return_data.size) + _14 + 351 len 1]
mem[(2 * ceil32(return_data.size)) + 320] = mem[ceil32(return_data.size) + _14 + 320]
require mem[ceil32(return_data.size) + _14 + 352] == mem[ceil32(return_data.size) + _14 + 383 len 1]
mem[(2 * ceil32(return_data.size)) + 352] = mem[ceil32(return_data.size) + _14 + 352]
_25 = mem[ceil32(return_data.size) + _14 + 384]
require mem[ceil32(return_data.size) + _14 + 384] <= 18446744073709551615
require ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 127 <′ ceil32(return_data.size) + return_data.size + 96
_26 = mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96]
if mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96] > 18446744073709551615:
revert with 'NH{q', 65
if ceil32(ceil32(mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96])) + 321 < 320 or (2 * ceil32(return_data.size)) + ceil32(ceil32(mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96])) + 417 > 18446744073709551615:
revert with 'NH{q', 65
mem[64] = (2 * ceil32(return_data.size)) + ceil32(ceil32(mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96])) + 417
mem[(2 * ceil32(return_data.size)) + 416] = mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96]
require _14 + _25 + _26 + 32 <= return_data.size
mem[(2 * ceil32(return_data.size)) + 448 len ceil32(_26)] = mem[ceil32(return_data.size) + _14 + _25 + 128 len ceil32(_26)]
if ceil32(_26) > _26:
mem[_26 + (2 * ceil32(return_data.size)) + 448] = 0
mem[(2 * ceil32(return_data.size)) + 384] = (2 * ceil32(return_data.size)) + 416
mem[mem[64]] = mem[(2 * ceil32(return_data.size)) + 236 len 20]
return memory
from mem[64]
len 32
def unknownd0f1259c(uint256 _param1) payable:
require calldata.size - 4 >=′ 32
if 1 == addr(ownerOf[_param1].field_0):
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'PresenceClaim: presence claim does not exist'
mem[0] = _param1
mem[32] = 3
if not addr(ownerOf[_param1].field_0):
revert with 0x8c379a000000000000000000000000000000000000000000000000000000000, 'PresenceClaim: presence claim does not exist'
static call unknown660c4af3Address.0x5558f555 with:
gas gas_remaining wei
mem[96] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >=′ 32
require ext_call.return_data == ext_call.return_data[12 len 20]
mem[ceil32(return_data.size) + 96] = 0xb5f951bd00000000000000000000000000000000000000000000000000000000
mem[ceil32(return_data.size) + 100] = _param1
static call addr(ext_call.return_data).0xb5f951bd with:
gas gas_remaining wei
args _param1
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
mem[ceil32(return_data.size) + 96 len return_data.size] = ext_call.return_data[0 len return_data.size]
require return_data.size >=′ 32
_14 = mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32
require mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32 <= 18446744073709551615
require return_data.size - mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32 >=′ 320
if not bool((2 * ceil32(return_data.size)) + 416 <= 18446744073709551615):
revert with 'NH{q', 65
mem[64] = (2 * ceil32(return_data.size)) + 416
mem[(2 * ceil32(return_data.size)) + 96] = mem[ceil32(return_data.size) + mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32 + 96]
mem[(2 * ceil32(return_data.size)) + 128] = mem[ceil32(return_data.size) + _14 + 128]
require mem[ceil32(return_data.size) + _14 + 160] == mem[ceil32(return_data.size) + _14 + 180 len 12]
mem[(2 * ceil32(return_data.size)) + 160] = mem[ceil32(return_data.size) + _14 + 160]
require mem[ceil32(return_data.size) + _14 + 192] == Mask(160, 96, mem[ceil32(return_data.size) + _14 + 192])
mem[(2 * ceil32(return_data.size)) + 192] = mem[ceil32(return_data.size) + _14 + 192]
require mem[ceil32(return_data.size) + _14 + 224] == mem[ceil32(return_data.size) + _14 + 236 len 20]
mem[(2 * ceil32(return_data.size)) + 224] = mem[ceil32(return_data.size) + _14 + 224]
require mem[ceil32(return_data.size) + _14 + 256] == mem[ceil32(return_data.size) + _14 + 276 len 12]
mem[(2 * ceil32(return_data.size)) + 256] = mem[ceil32(return_data.size) + _14 + 256]
require mem[ceil32(return_data.size) + _14 + 288] == mem[ceil32(return_data.size) + _14 + 316 len 4]
mem[(2 * ceil32(return_data.size)) + 288] = mem[ceil32(return_data.size) + _14 + 288]
require mem[ceil32(return_data.size) + _14 + 320] == mem[ceil32(return_data.size) + _14 + 351 len 1]
mem[(2 * ceil32(return_data.size)) + 320] = mem[ceil32(return_data.size) + _14 + 320]
require mem[ceil32(return_data.size) + _14 + 352] == mem[ceil32(return_data.size) + _14 + 383 len 1]
mem[(2 * ceil32(return_data.size)) + 352] = mem[ceil32(return_data.size) + _14 + 352]
_25 = mem[ceil32(return_data.size) + _14 + 384]
require mem[ceil32(return_data.size) + _14 + 384] <= 18446744073709551615
require ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 127 <′ ceil32(return_data.size) + return_data.size + 96
_26 = mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96]
if mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96] > 18446744073709551615:
revert with 'NH{q', 65
if ceil32(ceil32(mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96])) + 321 < 320 or (2 * ceil32(return_data.size)) + ceil32(ceil32(mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96])) + 417 > 18446744073709551615:
revert with 'NH{q', 65
mem[64] = (2 * ceil32(return_data.size)) + ceil32(ceil32(mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96])) + 417
mem[(2 * ceil32(return_data.size)) + 416] = mem[ceil32(return_data.size) + _14 + mem[ceil32(return_data.size) + _14 + 384] + 96]
require _14 + _25 + _26 + 32 <= return_data.size
mem[(2 * ceil32(return_data.size)) + 448 len ceil32(_26)] = mem[ceil32(return_data.size) + _14 + _25 + 128 len ceil32(_26)]
if ceil32(_26) > _26:
mem[_26 + (2 * ceil32(return_data.size)) + 448] = 0
mem[(2 * ceil32(return_data.size)) + 384] = (2 * ceil32(return_data.size)) + 416
if mem[(2 * ceil32(return_data.size)) + 351 len 1] > 2:
revert with 'NH{q', 33
if mem[(2 * ceil32(return_data.size)) + 351 len 1] >= 3:
revert with 'NH{q', 33
mem[mem[64]] = mem[(2 * ceil32(return_data.size)) + 351 len 1]
return memory
from mem[64]
len 32
def name() payable:
if bool(stor1.length):
if not bool(stor1.length) - (uint255(stor1.length) * 0.5 < 32):
revert with 'NH{q', 34
if bool(stor1.length):
if not bool(stor1.length) - (uint255(stor1.length) * 0.5 < 32):
revert with 'NH{q', 34
if Mask(256, -1, stor1.length):
if 31 < uint255(stor1.length) * 0.5:
mem[128] = uint256(stor1.field_0)
idx = 128
s = 0
while (uint255(stor1.length) * 0.5) + 96 > idx:
mem[idx + 32] = stor1[s].field_256
idx = idx + 32
s = s + 1
continue
return Array(len=2 * Mask(256, -1, stor1.length), data=mem[128 len ceil32(uint255(stor1.length) * 0.5)])
mem[128] = 256 * Mask(248, 0, stor1.length.field_8)
else:
if not bool(stor1.length) - (stor1.length.field_1 % 128 < 32):
revert with 'NH{q', 34
if stor1.length.field_1 % 128:
if 31 < stor1.length.field_1 % 128:
mem[128] = uint256(stor1.field_0)
idx = 128
s = 0
while stor1.length.field_1 % 128 + 96 > idx:
mem[idx + 32] = stor1[s].field_256
idx = idx + 32
s = s + 1
continue
return Array(len=2 * Mask(256, -1, stor1.length), data=mem[128 len ceil32(uint255(stor1.length) * 0.5)])
mem[128] = 256 * Mask(248, 0, stor1.length.field_8)
mem[ceil32(uint255(stor1.length) * 0.5) + 192 len ceil32(uint255(stor1.length) * 0.5)] = mem[128 len ceil32(uint255(stor1.length) * 0.5)]
if ceil32(uint255(stor1.length) * 0.5) > uint255(stor1.length) * 0.5:
mem[(uint255(stor1.length) * 0.5) + ceil32(uint255(stor1.length) * 0.5) + 192] = 0
return Array(len=2 * Mask(256, -1, stor1.length), data=mem[128 len ceil32(uint255(stor1.length) * 0.5)], mem[(2 * ceil32(uint255(stor1.length) * 0.5)) + 192 len 2 * ceil32(uint255(stor1.length) * 0.5)]),
if not bool(stor1.length) - (stor1.length.field_1 % 128 < 32):
revert with 'NH{q', 34
if bool(stor1.length):
if not bool(stor1.length) - (uint255(stor1.length) * 0.5 < 32):
revert with 'NH{q', 34
if Mask(256, -1, stor1.length):
if 31 < uint255(stor1.length) * 0.5:
mem[128] = uint256(stor1.field_0)
idx = 128
s = 0
while (uint255(stor1.length) * 0.5) + 96 > idx:
mem[idx + 32] = stor1[s].field_256
idx = idx + 32
s = s + 1
continue
return Array(len=stor1.length % 128, data=mem[128 len ceil32(stor1.length.field_1 % 128)])
mem[128] = 256 * Mask(248, 0, stor1.length.field_8)
else:
if not bool(stor1.length) - (stor1.length.field_1 % 128 < 32):
revert with 'NH{q', 34
if stor1.length.field_1 % 128:
if 31 < stor1.length.field_1 % 128:
mem[128] = uint256(stor1.field_0)
idx = 128
s = 0
while stor1.length.field_1 % 128 + 96 > idx:
mem[idx + 32] = stor1[s].field_256
idx = idx + 32
s = s + 1
continue
return Array(len=stor1.length % 128, data=mem[128 len ceil32(stor1.length.field_1 % 128)])
mem[128] = 256 * Mask(248, 0, stor1.length.field_8)
mem[ceil32(stor1.length.field_1 % 128) + 192 len ceil32(stor1.length.field_1 % 128)] = mem[128 len ceil32(stor1.length.field_1 % 128)]
if ceil32(stor1.length.field_1 % 128) > stor1.length.field_1 % 128:
mem[stor1.length.field_1 % 128 + ceil32(stor1.length.field_1 % 128) + 192] = 0
return Array(len=stor1.length % 128, data=mem[128 len ceil32(stor1.length.field_1 % 128)], mem[(2 * ceil32(stor1.length.field_1 % 128)) + 192 len 2 * ceil32(stor1.length.field_1 % 128)]),
def symbol() payable:
if bool(stor2.length):
if not bool(stor2.length) - (uint255(stor2.length) * 0.5 < 32):
revert with 'NH{q', 34
if bool(stor2.length):
if not bool(stor2.length) - (uint255(stor2.length) * 0.5 < 32):
revert with 'NH{q', 34
if Mask(256, -1, stor2.length):
if 31 < uint255(stor2.length) * 0.5:
mem[128] = uint256(stor2.field_0)
idx = 128
s = 0
while (uint255(stor2.length) * 0.5) + 96 > idx:
mem[idx + 32] = stor2[s].field_256
idx = idx + 32
s = s + 1
continue
return Array(len=2 * Mask(256, -1, stor2.length), data=mem[128 len ceil32(uint255(stor2.length) * 0.5)])
mem[128] = 256 * Mask(248, 0, stor2.length.field_8)
else:
if not bool(stor2.length) - (stor2.length.field_1 % 128 < 32):
revert with 'NH{q', 34
if stor2.length.field_1 % 128:
if 31 < stor2.length.field_1 % 128:
mem[128] = uint256(stor2.field_0)
idx = 128
s = 0
while stor2.length.field_1 % 128 + 96 > idx:
mem[idx + 32] = stor2[s].field_256
idx = idx + 32
s = s + 1
continue
return Array(len=2 * Mask(256, -1, stor2.length), data=mem[128 len ceil32(uint255(stor2.length) * 0.5)])
mem[128] = 256 * Mask(248, 0, stor2.length.field_8)
mem[ceil32(uint255(stor2.length) * 0.5) + 192 len ceil32(uint255(stor2.length) * 0.5)] = mem[128 len ceil32(uint255(stor2.length) * 0.5)]
if ceil32(uint255(stor2.length) * 0.5) > uint255(stor2.length) * 0.5:
mem[(uint255(stor2.length) * 0.5) + ceil32(uint255(stor2.length) * 0.5) + 192] = 0
return Array(len=2 * Mask(256, -1, stor2.length), data=mem[128 len ceil32(uint255(stor2.length) * 0.5)], mem[(2 * ceil32(uint255(stor2.length) * 0.5)) + 192 len 2 * ceil32(uint255(stor2.length) * 0.5)]),
if not bool(stor2.length) - (stor2.length.field_1 % 128 < 32):
revert with 'NH{q', 34
if bool(stor2.length):
if not bool(stor2.length) - (uint255(stor2.length) * 0.5 < 32):
revert with 'NH{q', 34
if Mask(256, -1, stor2.length):
if 31 < uint255(stor2.length) * 0.5:
mem[128] = uint256(stor2.field_0)
idx = 128
s = 0
while (uint255(stor2.length) * 0.5) + 96 > idx:
mem[idx + 32] = stor2[s].field_256
idx = idx + 32
s = s + 1
continue
return Array(len=stor2.length % 128, data=mem[128 len ceil32(stor2.length.field_1 % 128)])
mem[128] = 256 * Mask(248, 0, stor2.length.field_8)
else:
if not bool(stor2.length) - (stor2.length.field_1 % 128 < 32):
revert with 'NH{q', 34
if stor2.length.field_1 % 128:
if 31 < stor2.length.field_1 % 128:
mem[128] = uint256(stor2.field_0)
idx = 128
s = 0
while stor2.length.field_1 % 128 + 96 > idx:
mem[idx + 32] = stor2[s].field_256
idx = idx + 32
s = s + 1
continue
return Array(len=stor2.length % 128, data=mem[128 len ceil32(stor2.length.field_1 % 128)])
mem[128] = 256 * Mask(248, 0, stor2.length.field_8)
mem[ceil32(stor2.length.field_1 % 128) + 192 len ceil32(stor2.length.field_1 % 128)] = mem[128 len ceil32(stor2.length.field_1 % 128)]
if ceil32(stor2.length.field_1 % 128) > stor2.length.field_1 % 128:
mem[stor2.length.field_1 % 128 + ceil32(stor2.length.field_1 % 128) + 192] = 0
return Array(len=stor2.length % 128, data=mem[128 len ceil32(stor2.length.field_1 % 128)], mem[(2 * ceil32(stor2.length.field_1 % 128)) + 192 len 2 * ceil32(stor2.length.field_1 % 128)]),
def tokenURIPrefix() payable:
if bool(stor9.length):
if not bool(stor9.length) - (uint255(stor9.length) * 0.5 < 32):
revert with 'NH{q', 34
if bool(stor9.length):
if not bool(stor9.length) - (uint255(stor9.length) * 0.5 < 32):
revert with 'NH{q', 34
if Mask(256, -1, stor9.length):
if 31 < uint255(stor9.length) * 0.5:
mem[128] = uint256(stor9.field_0)
idx = 128
s = 0
while (uint255(stor9.length) * 0.5) + 96 > idx:
mem[idx + 32] = stor9[s].field_256
idx = idx + 32
s = s + 1
continue
return Array(len=2 * Mask(256, -1, stor9.length), data=mem[128 len ceil32(uint255(stor9.length) * 0.5)])
mem[128] = 256 * Mask(248, 0, stor9.length.field_8)
else:
if not bool(stor9.length) - (stor9.length.field_1 % 128 < 32):
revert with 'NH{q', 34
if stor9.length.field_1 % 128:
if 31 < stor9.length.field_1 % 128:
mem[128] = uint256(stor9.field_0)
idx = 128
s = 0
while stor9.length.field_1 % 128 + 96 > idx:
mem[idx + 32] = stor9[s].field_256
idx = idx + 32
s = s + 1
continue
return Array(len=2 * Mask(256, -1, stor9.length), data=mem[128 len ceil32(uint255(stor9.length) * 0.5)])
mem[128] = 256 * Mask(248, 0, stor9.length.field_8)
mem[ceil32(uint255(stor9.length) * 0.5) + 192 len ceil32(uint255(stor9.length) * 0.5)] = mem[128 len ceil32(uint255(stor9.length) * 0.5)]
if ceil32(uint255(stor9.length) * 0.5) > uint255(stor9.length) * 0.5:
mem[(uint255(stor9.length) * 0.5) + ceil32(uint255(stor9.length) * 0.5) + 192] = 0
return Array(len=2 * Mask(256, -1, stor9.length), data=mem[128 len ceil32(uint255(stor9.length) * 0.5)], mem[(2 * ceil32(uint255(stor9.length) * 0.5)) + 192 len 2 * ceil32(uint255(stor9.length) * 0.5)]),
if not bool(stor9.length) - (stor9.length.field_1 % 128 < 32):
revert with 'NH{q', 34
if bool(stor9.length):
if not bool(stor9.length) - (uint255(stor9.length) * 0.5 < 32):
revert with 'NH{q', 34
if Mask(256, -1, stor9.length):
if 31 < uint255(stor9.length) * 0.5:
mem[128] = uint256(stor9.field_0)
idx = 128
s = 0
while (uint255(stor9.length) * 0.5) + 96 > idx:
mem[idx + 32] = stor9[s].field_256
idx = idx + 32
s = s + 1
continue
return Array(len=stor9.length % 128, data=mem[128 len ceil32(stor9.length.field_1 % 128)])
mem[128] = 256 * Mask(248, 0, stor9.length.field_8)
else:
if not bool(stor9.length) - (stor9.length.field_1 % 128 < 32):
revert with 'NH{q', 34
if stor9.length.field_1 % 128:
if 31 < stor9.length.field_1 % 128:
mem[128] = uint256(stor9.field_0)
idx = 128
s = 0
while stor9.length.field_1 % 128 + 96 > idx:
mem[idx + 32] = stor9[s].field_256
idx = idx + 32
s = s + 1
continue
return Array(len=stor9.length % 128, data=mem[128 len ceil32(stor9.length.field_1 % 128)])
mem[128] = 256 * Mask(248, 0, stor9.length.field_8)
mem[ceil32(stor9.length.field_1 % 128) + 192 len ceil32(stor9.length.field_1 % 128)] = mem[128 len ceil32(stor9.length.field_1 % 128)]
if ceil32(stor9.length.field_1 % 128) > stor9.length.field_1 % 128:
mem[stor9.length.field_1 % 128 + ceil32(stor9.length.field_1 % 128) + 192] = 0
return Array(len=stor9.length % 128, data=mem[128 len ceil32(stor9.length.field_1 % 128)], mem[(2 * ceil32(stor9.length.field_1 % 128)) + 192 len 2 * ceil32(stor9.length.field_1 % 128)]),
def unknowna9852bfb() payable:
require calldata.size - 4 >=′ 32
require cd <= 18446744073709551615
require cd <′ calldata.size
require ('cd', 4).length <= 18446744073709551615
require cd('cd', 4).length + 36 <= calldata.size
if owner != caller:
revert with 0, 'Ownable: caller is not the owner'
if ('cd', 4).length > 18446744073709551615:
revert with 'NH{q', 65
if bool(stor10.length):
if not bool(stor10.length) - (uint255(stor10.length) * 0.5 < 32):
revert with 'NH{q', 34
if uint255(stor10.length) * 0.5 <= 31:
if ('cd', 4).length > 31 != 1:
if not ('cd', 4).length:
stor10.length = 2 * ('cd', 4).length
else:
stor10.length = ('cd', 4).length
else:
idx = 0
s = 0
t = 0
while idx < floor32(('cd', 4).length):
stor10[s].field_0 = cd[(t + cd[4] + 36)]
idx = idx + 32
s = s + 1
t = t + 32
continue
if floor32(('cd', 4).length) < ('cd', 4).length:
stor10[Mask(251, 0, floor32(('cd', 4).length) + 31) >> 5].field_0 = cd[(cd('cd', 4).length)) + 36)] and !(Mask(256, -8 * ('cd', 4).length % 32, -1) >> 8 * ('cd', 4).length % 32)
stor10.length = (2 * ('cd', 4).length) + 1
else:
if ('cd', 4).length >= 32:
idx = Mask(251, 0, ('cd', 4).length + 31) * 0.03125
while idx < Mask(251, 0, (uint255(stor10.length) * 0.5) + 31) * 0.03125:
stor10[idx].field_0 = 0
idx = idx + 1
continue
else:
idx = 0
while idx < Mask(251, 0, (uint255(stor10.length) * 0.5) + 31) * 0.03125:
stor10[idx].field_0 = 0
idx = idx + 1
continue
if ('cd', 4).length > 31 != 1:
if not ('cd', 4).length:
stor10.length = 2 * ('cd', 4).length
else:
stor10.length = ('cd', 4).length
else:
idx = 0
s = 0
t = 0
while idx < floor32(('cd', 4).length):
stor10[s].field_0 = cd[(t + cd[4] + 36)]
idx = idx + 32
s = s + 1
t = t + 32
continue
if floor32(('cd', 4).length) < ('cd', 4).length:
stor10[Mask(251, 0, floor32(('cd', 4).length) + 31) >> 5].field_0 = cd[(cd('cd', 4).length)) + 36)] and !(Mask(256, -8 * ('cd', 4).length % 32, -1) >> 8 * ('cd', 4).length % 32)
stor10.length = (2 * ('cd', 4).length) + 1
else:
if not bool(stor10.length) - (stor10.length.field_1 % 128 < 32):
revert with 'NH{q', 34
if stor10.length.field_1 % 128 <= 31:
if ('cd', 4).length > 31 != 1:
if not ('cd', 4).length:
stor10.length = 2 * ('cd', 4).length
else:
stor10.length = ('cd', 4).length
else:
idx = 0
s = 0
t = 0
while idx < floor32(('cd', 4).length):
stor10[s].field_0 = cd[(t + cd[4] + 36)]
idx = idx + 32
s = s + 1
t = t + 32
continue
if floor32(('cd', 4).length) < ('cd', 4).length:
stor10[Mask(251, 0, floor32(('cd', 4).length) + 31) >> 5].field_0 = cd[(cd('cd', 4).length)) + 36)] and !(Mask(256, -8 * ('cd', 4).length % 32, -1) >> 8 * ('cd', 4).length % 32)
stor10.length = (2 * ('cd', 4).length) + 1
else:
if ('cd', 4).length >= 32:
idx = Mask(251, 0, ('cd', 4).length + 31) * 0.03125
while idx < Mask(251, 0, stor10.length.field_1 % 128 + 31) * 0.03125:
stor10[idx].field_0 = 0
idx = idx + 1
continue
else:
idx = 0
while idx < Mask(251, 0, stor10.length.field_1 % 128 + 31) * 0.03125:
stor10[idx].field_0 = 0
idx = idx + 1
continue
if ('cd', 4).length > 31 != 1:
if not ('cd', 4).length:
stor10.length = 2 * ('cd', 4).length
else:
stor10.length = ('cd', 4).length
else:
idx = 0
s = 0
t = 0
while idx < floor32(('cd', 4).length):
stor10[s].field_0 = cd[(t + cd[4] + 36)]
idx = idx + 32
s = s + 1
t = t + 32
continue
if floor32(('cd', 4).length) < ('cd', 4).length:
stor10[Mask(251, 0, floor32(('cd', 4).length) + 31) >> 5].field_0 = cd[(cd('cd', 4).length)) + 36)] and !(Mask(256, -8 * ('cd', 4).length % 32, -1) >> 8 * ('cd', 4).length % 32)
stor10.length = (2 * ('cd', 4).length) + 1
def tokenURISuffix() payable:
if bool(stor10.length):
if not bool(stor10.length) - (uint255(stor10.length) * 0.5 < 32):
revert with 'NH{q', 34
if bool(stor10.length):
if not bool(stor10.length) - (uint255(stor10.length) * 0.5 < 32):
revert with 'NH{q', 34
if Mask(256, -1, stor10.length):
if 31 < uint255(stor10.length) * 0.5:
mem[128] = uint256(stor10.field_0)
idx = 128
s = 0
while (uint255(stor10.length) * 0.5) + 96 > idx:
mem[idx + 32] = stor10[s].field_256
idx = idx + 32
s = s + 1
continue
return Array(len=2 * Mask(256, -1, stor10.length), data=mem[128 len ceil32(uint255(stor10.length) * 0.5)])
mem[128] = 256 * Mask(248, 0, stor10.length.field_8)
else:
if not bool(stor10.length) - (stor10.length.field_1 % 128 < 32):
revert with 'NH{q', 34
if stor10.length.field_1 % 128:
if 31 < stor10.length.field_1 % 128:
mem[128] = uint256(stor10.field_0)
idx = 128
s = 0
while stor10.length.field_1 % 128 + 96 > idx:
mem[idx + 32] = stor10[s].field_256
idx = idx + 32
s = s + 1
continue
return Array(len=2 * Mask(256, -1, stor10.length), data=mem[128 len ceil32(uint255(stor10.length) * 0.5)])
mem[128] = 256 * Mask(248, 0, stor10.length.field_8)
mem[ceil32(uint255(stor10.length) * 0.5) + 192 len ceil32(uint255(stor10.length) * 0.5)] = mem[128 len ceil32(uint255(stor10.length) * 0.5)]
if ceil32(uint255(stor10.length) * 0.5) > uint255(stor10.length) * 0.5:
mem[(uint255(stor10.length) * 0.5) + ceil32(uint255(stor10.length) * 0.5) + 192] = 0
return Array(len=2 * Mask(256, -1, stor10.length), data=mem[128 len ceil32(uint255(stor10.length) * 0.5)], mem[(2 * ceil32(uint255(stor10.length) * 0.5)) + 192 len 2 * ceil32(uint255(stor10.length) * 0.5)]),
if not bool(stor10.length) - (stor10.length.field_1 % 128 < 32):
revert with 'NH{q', 34
if bool(stor10.length):
if not bool(stor10.length) - (uint255(stor10.length) * 0.5 < 32):
revert with 'NH{q', 34
if Mask(256, -1, stor10.length):
if 31 < uint255(stor10.length) * 0.5:
mem[128] = uint256(stor10.field_0)
idx = 128
s = 0
while (uint255(stor10.length) * 0.5) + 96 > idx:
mem[idx + 32] = stor10[s].field_256
idx = idx + 32
s = s + 1
continue
return Array(len=stor10.length % 128, data=mem[128 len ceil32(stor10.length.field_1 % 128)])
mem[128] = 256 * Mask(248, 0, stor10.length.field_8)
else:
if not bool(stor10.length) - (stor10.length.field_1 % 128 < 32):
revert with 'NH{q', 34
if stor10.length.field_1 % 128:
if 31 < stor10.length.field_1 % 128:
mem[128] = uint256(stor10.field_0)
idx = 128
s = 0
while stor10.length.field_1 % 128 + 96 > idx:
mem[idx + 32] = stor10[s].field_256
idx = idx + 32
s = s + 1
continue
return Array(len=stor10.length % 128, data=mem[128 len ceil32(stor10.length.field_1 % 128)])
mem[128] = 256 * Mask(248, 0, stor10.length.field_8)
mem[ceil32(stor10.length.field_1 % 128) + 192 len ceil32(stor10.length.field_1 % 128)] = mem[128 len ceil32(stor10.length.field_1 % 128)]
if ceil32(stor10.length.field_1 % 128) > stor10.length.field_1 % 128:
mem[stor10.length.field_1 % 128 + ceil32(stor10.length.field_1 % 128) + 192] = 0
return Array(len=stor10.length % 128, data=mem[128 len ceil32(stor10.length.field_1 % 128)], mem[(2 * ceil32(stor10.length.field_1 % 128)) + 192 len 2 * ceil32(stor10.length.field_1 % 128)]),
def setTokenURIPrefix(string _newPrefix) payable:
require calldata.size - 4 >=′ 32
require _newPrefix <= 18446744073709551615
require _newPrefix + 35 <′ calldata.size
require _newPrefix.length <= 18446744073709551615
require _newPrefix + _newPrefix.length + 36 <= calldata.size
if owner != caller:
revert with 0, 'Ownable: caller is not the owner'
if _newPrefix.length > 18446744073709551615:
revert with 'NH{q', 65
if bool(stor9.length):
if not bool(stor9.length) - (uint255(stor9.length) * 0.5 < 32):
revert with 'NH{q', 34
if uint255(stor9.length) * 0.5 <= 31:
if _newPrefix.length > 31 != 1:
if not _newPrefix.length:
stor9.length = 2 * _newPrefix.length
else:
stor9.length = _newPrefix.length
else:
idx = 0
s = 0
t = 0
while idx < floor32(_newPrefix.length):
stor9[s].field_0 = cd[(t + _newPrefix + 36)]
idx = idx + 32
s = s + 1
t = t + 32
continue
if floor32(_newPrefix.length) < _newPrefix.length:
stor9[Mask(251, 0, floor32(_newPrefix.length) + 31) >> 5].field_0 = cd[(_newPrefix + ceil32(floor32(_newPrefix.length)) + 36)] and !(Mask(256, -8 * _newPrefix.length % 32, -1) >> 8 * _newPrefix.length % 32)
stor9.length = (2 * _newPrefix.length) + 1
else:
if _newPrefix.length >= 32:
idx = Mask(251, 0, _newPrefix.length + 31) * 0.03125
while idx < Mask(251, 0, (uint255(stor9.length) * 0.5) + 31) * 0.03125:
stor9[idx].field_0 = 0
idx = idx + 1
continue
else:
idx = 0
while idx < Mask(251, 0, (uint255(stor9.length) * 0.5) + 31) * 0.03125:
stor9[idx].field_0 = 0
idx = idx + 1
continue
if _newPrefix.length > 31 != 1:
if not _newPrefix.length:
stor9.length = 2 * _newPrefix.length
else:
stor9.length = _newPrefix.length
else:
idx = 0
s = 0
t = 0
while idx < floor32(_newPrefix.length):
stor9[s].field_0 = cd[(t + _newPrefix + 36)]
idx = idx + 32
s = s + 1
t = t + 32
continue
if floor32(_newPrefix.length) < _newPrefix.length:
stor9[Mask(251, 0, floor32(_newPrefix.length) + 31) >> 5].field_0 = cd[(_newPrefix + ceil32(floor32(_newPrefix.length)) + 36)] and !(Mask(256, -8 * _newPrefix.length % 32, -1) >> 8 * _newPrefix.length % 32)
stor9.length = (2 * _newPrefix.length) + 1
else:
if not bool(stor9.length) - (stor9.length.field_1 % 128 < 32):
revert with 'NH{q', 34
if stor9.length.field_1 % 128 <= 31:
if _newPrefix.length > 31 != 1:
if not _newPrefix.length:
stor9.length = 2 * _newPrefix.length
else:
stor9.length = _newPrefix.length
else:
idx = 0
s = 0
t = 0
while idx < floor32(_newPrefix.length):
stor9[s].field_0 = cd[(t + _newPrefix + 36)]
idx = idx + 32
s = s + 1
t = t + 32
continue
if floor32(_newPrefix.length) < _newPrefix.length:
stor9[Mask(251, 0, floor32(_newPrefix.length) + 31) >> 5].field_0 = cd[(_newPrefix + ceil32(floor32(_newPrefix.length)) + 36)] and !(Mask(256, -8 * _newPrefix.length % 32, -1) >> 8 * _newPrefix.length % 32)
stor9.length = (2 * _newPrefix.length) + 1
else:
if _newPrefix.length >= 32:
idx = Mask(251, 0, _newPrefix.length + 31) * 0.03125
while idx < Mask(251, 0, stor9.length.field_1 % 128 + 31) * 0.03125:
stor9[idx].field_0 = 0
idx = idx + 1
continue
else:
idx = 0
while idx < Mask(251, 0, stor9.length.field_1 % 128 + 31) * 0.03125:
stor9[idx].field_0 = 0
idx = idx + 1
continue
if _newPrefix.length > 31 != 1:
if not _newPrefix.length:
stor9.length = 2 * _newPrefix.length
else:
stor9.length = _newPrefix.length
else:
idx = 0
s = 0
t = 0
while idx < floor32(_newPrefix.length):
stor9[s].field_0 = cd[(t + _newPrefix + 36)]
idx = idx + 32
s = s + 1
t = t + 32
continue
if floor32(_newPrefix.length) < _newPrefix.length:
stor9[Mask(251, 0, floor32(_newPrefix.length) + 31) >> 5].field_0 = cd[(_newPrefix + ceil32(floor32(_newPrefix.length)) + 36)] and !(Mask(256, -8 * _newPrefix.length % 32, -1) >> 8 * _newPrefix.length % 32)
stor9.length = (2 * _newPrefix.length) + 1
def unknownf687318c() payable:
require calldata.size - 4 >=′ 128
require cd <= 18446744073709551615
require cd <′ calldata.size
if ('cd', 68).length > 18446744073709551615:
revert with 'NH{q', 65
if ceil32(ceil32(('cd', 68).length)) + 97 < 96 or ceil32(ceil32(('cd', 68).length)) + 97 > 18446744073709551615:
revert with 'NH{q', 65
mem[96] = ('cd', 68).length
require cd('cd', 68).length + 36 <= calldata.size
mem[128 len ('cd', 68).length] = call.data[cd('cd', 68).length]
mem[('cd', 68).length + 128] = 0
require cd <= 18446744073709551615
require cd <′ calldata.size
if ('cd', 100).length > 18446744073709551615:
revert with 'NH{q', 65
if ceil32(32 * ('cd', 100).length) + 98 < 97 or ceil32(ceil32(('cd', 68).length)) + ceil32(32 * ('cd', 100).length) + 98 > 18446744073709551615:
revert with 'NH{q', 65
mem[64] = ceil32(ceil32(('cd', 68).length)) + ceil32(32 * ('cd', 100).length) + 98
mem[ceil32(ceil32(('cd', 68).length)) + 97] = ('cd', 100).length
require (32 * ('cd', 100).length) + cd <= calldata.size
s = ceil32(ceil32(('cd', 68).length)) + 129
idx = cd[100] + 36
while idx < (32 * ('cd', 100).length) + cd:
require cd[idx] <= 18446744073709551615
require cdidx] + 67 <′ calldata.size
if cd[(cdidx] + 36)] > 18446744073709551615:
revert with 'NH{q', 65
_345 = mem[64]
if mem[64] + ceil32(ceil32(cd[(cdidx] + 36)])) + 1 < mem[64] or mem[64] + ceil32(ceil32(cd[(cdidx] + 36)])) + 1 > 18446744073709551615:
revert with 'NH{q', 65
mem[64] = mem[64] + ceil32(ceil32(cd[(cdidx] + 36)])) + 1
mem[_345] = cd[(cdidx] + 36)]
require cdidx] + cd[(cdidx] + 36)] + 68 <= calldata.size
mem[_345 + 32 len cd[(cdidx] + 36)]] = call.data[cdidx] + 68 len cd[(cdidx] + 36)]]
mem[_345 + cd[(cdidx] + 36)] + 32] = 0
mem[s] = _345
s = s + 32
idx = idx + 32
continue
_343 = mem[64]
mem[mem[64]] = 0x929d98f100000000000000000000000000000000000000000000000000000000
mem[mem[64] + 4] = cd[36]
mem[mem[64] + 36] = 96
_344 = mem[96]
mem[mem[64] + 100] = mem[96]
mem[mem[64] + 132 len ceil32(mem[96])] = mem[128 len ceil32(mem[96])]
if ceil32(mem[96]) <= mem[96]:
mem[mem[64] + 68] = ceil32(mem[96]) + 128
_684 = mem[ceil32(ceil32(('cd', 68).length)) + 97]
mem[ceil32(mem[96]) + mem[64] + 132] = mem[ceil32(ceil32(('cd', 68).length)) + 97]
idx = 0
s = ceil32(ceil32(('cd', 68).length)) + 129
t = ceil32(mem[96]) + mem[64] + (32 * _684) + 164
u = ceil32(mem[96]) + mem[64] + 164
while idx < _684:
mem[u] = t + -ceil32(_344) + -_343 - 164
_1020 = mem[s]
_1023 = mem[mem[s]]
mem[t] = mem[mem[s]]
v = 0
while v < _1023:
mem[v + t + 32] = mem[v + _1020 + 32]
v = v + 32
continue
if ceil32(_1023) > _1023:
mem[_1023 + t + 32] = 0
idx = idx + 1
s = s + 32
t = ceil32(_1023) + t + 32
u = u + 32
continue
require ext_code.size(unknown660c4af3Address)
call unknown660c4af3Address.mem[mem[64] len 4] with:
gas gas_remaining wei
args mem[mem[64] + 4 len t + -mem[64] - 4]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
mem[mem[64] + 4] = cd[4]
static call unknownf40e73c9Address.ownerOf(uint256 deedId) with:
gas gas_remaining wei
args cd[4]
mem[mem[64]] = ext_call.return_data[0]
_1032 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
_1034 = mem[_1032]
require mem[_1032] == mem[_1032 + 12 len 20]
mem[mem[64] + 36] = cd[36]
require ext_code.size(unknownf40e73c9Address)
call unknownf40e73c9Address.0x7f7499c3 with:
gas gas_remaining wei
args cd[4], cd[36]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
mem[mem[64] + 4] = cd[36]
static call unknown660c4af3Address.0xce6915fa with:
gas gas_remaining wei
args cd[36]
mem[mem[64]] = ext_call.return_data[0]
_1044 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_1044] == bool(mem[_1044])
if not mem[_1044]:
revert with 0, 'PresenceClaim: _safeMint: CID has not been validated!'
_1050 = mem[64]
mem[64] = mem[64] + 32
mem[_1050] = 0
if not addr(_1034):
revert with 0, 'ERC721: mint to the zero address'
if 1 == addr(ownerOf[cd].field_0):
if 1 == addr(ownerOf[cd].field_0):
balanceOf[addr(_1034)]++
mem[0] = cd[36]
mem[32] = 3
addr(ownerOf[cd].field_0) = addr(_1034)
log Transfer(
address from=0,
address to=addr(_1034),
uint256 tokens=cd
if ext_code.size(addr(_1034)):
mem[mem[64] + 4] = caller
mem[mem[64] + 36] = 0
mem[mem[64] + 68] = cd[36]
mem[mem[64] + 100] = 128
mem[mem[64] + 132] = 0
mem[mem[64] + 164 len 0] = None
call addr(_1034).onERC721Received(address operator, address from, uint256 childTokenId, bytes data) with:
gas gas_remaining wei
args caller, 0, cd[36], 128, 0
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
if not return_data.size:
if not -mem[96]:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with memory
from 128
len mem[96]
if not -return_data.size:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with ext_call.return_data[0 len return_data.size]
_1380 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_1380] == Mask(32, 224, mem[_1380])
if Mask(32, 224, mem[_1380]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
else:
if addr(ownerOf[cd].field_0):
revert with 0, 'ERC721: token already minted'
balanceOf[addr(_1034)]++
mem[0] = cd[36]
mem[32] = 3
addr(ownerOf[cd].field_0) = addr(_1034)
log Transfer(
address from=0,
address to=addr(_1034),
uint256 tokens=cd
if ext_code.size(addr(_1034)):
mem[mem[64] + 4] = caller
mem[mem[64] + 36] = 0
mem[mem[64] + 68] = cd[36]
mem[mem[64] + 100] = 128
mem[mem[64] + 132] = 0
mem[mem[64] + 164 len 0] = None
call addr(_1034).onERC721Received(address operator, address from, uint256 childTokenId, bytes data) with:
gas gas_remaining wei
args caller, 0, cd[36], 128, 0
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
if not return_data.size:
if not -mem[96]:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with memory
from 128
len mem[96]
if not -return_data.size:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with ext_call.return_data[0 len return_data.size]
_1382 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_1382] == Mask(32, 224, mem[_1382])
if Mask(32, 224, mem[_1382]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
else:
if addr(ownerOf[cd].field_0):
revert with 0, 'ERC721: token already minted'
if 1 == addr(ownerOf[cd].field_0):
balanceOf[addr(_1034)]++
mem[0] = cd[36]
mem[32] = 3
addr(ownerOf[cd].field_0) = addr(_1034)
log Transfer(
address from=0,
address to=addr(_1034),
uint256 tokens=cd
if ext_code.size(addr(_1034)):
mem[mem[64] + 4] = caller
mem[mem[64] + 36] = 0
mem[mem[64] + 68] = cd[36]
mem[mem[64] + 100] = 128
mem[mem[64] + 132] = 0
mem[mem[64] + 164 len 0] = None
call addr(_1034).onERC721Received(address operator, address from, uint256 childTokenId, bytes data) with:
gas gas_remaining wei
args caller, 0, cd[36], 128, 0
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
if not return_data.size:
if not -mem[96]:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with memory
from 128
len mem[96]
if not -return_data.size:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with ext_call.return_data[0 len return_data.size]
_1384 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_1384] == Mask(32, 224, mem[_1384])
if Mask(32, 224, mem[_1384]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
else:
if addr(ownerOf[cd].field_0):
revert with 0, 'ERC721: token already minted'
balanceOf[addr(_1034)]++
mem[0] = cd[36]
mem[32] = 3
addr(ownerOf[cd].field_0) = addr(_1034)
log Transfer(
address from=0,
address to=addr(_1034),
uint256 tokens=cd
if ext_code.size(addr(_1034)):
mem[mem[64] + 4] = caller
mem[mem[64] + 36] = 0
mem[mem[64] + 68] = cd[36]
mem[mem[64] + 100] = 128
mem[mem[64] + 132] = 0
mem[mem[64] + 164 len 0] = None
call addr(_1034).onERC721Received(address operator, address from, uint256 childTokenId, bytes data) with:
gas gas_remaining wei
args caller, 0, cd[36], 128, 0
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
if not return_data.size:
if not -mem[96]:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with memory
from 128
len mem[96]
if not -return_data.size:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with ext_call.return_data[0 len return_data.size]
_1386 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_1386] == Mask(32, 224, mem[_1386])
if Mask(32, 224, mem[_1386]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
else:
mem[mem[96] + mem[64] + 132] = 0
mem[mem[64] + 68] = ceil32(_344) + 128
_685 = mem[ceil32(ceil32(('cd', 68).length)) + 97]
mem[ceil32(_344) + _343 + 132] = mem[ceil32(ceil32(('cd', 68).length)) + 97]
idx = 0
s = ceil32(ceil32(('cd', 68).length)) + 129
t = ceil32(_344) + _343 + (32 * _685) + 164
u = ceil32(_344) + _343 + 164
while idx < _685:
mem[u] = t + -ceil32(_344) + -_343 - 164
_1021 = mem[s]
_1025 = mem[mem[s]]
mem[t] = mem[mem[s]]
v = 0
while v < _1025:
mem[v + t + 32] = mem[v + _1021 + 32]
v = v + 32
continue
if ceil32(_1025) > _1025:
mem[_1025 + t + 32] = 0
idx = idx + 1
s = s + 32
t = ceil32(_1025) + t + 32
u = u + 32
continue
require ext_code.size(unknown660c4af3Address)
call unknown660c4af3Address.mem[mem[64] len 4] with:
gas gas_remaining wei
args mem[mem[64] + 4 len t + -mem[64] - 4]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
mem[mem[64] + 4] = cd[4]
static call unknownf40e73c9Address.ownerOf(uint256 deedId) with:
gas gas_remaining wei
args cd[4]
mem[mem[64]] = ext_call.return_data[0]
_1033 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
_1035 = mem[_1033]
require mem[_1033] == mem[_1033 + 12 len 20]
mem[mem[64] + 36] = cd[36]
require ext_code.size(unknownf40e73c9Address)
call unknownf40e73c9Address.0x7f7499c3 with:
gas gas_remaining wei
args cd[4], cd[36]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
mem[mem[64] + 4] = cd[36]
static call unknown660c4af3Address.0xce6915fa with:
gas gas_remaining wei
args cd[36]
mem[mem[64]] = ext_call.return_data[0]
_1045 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_1045] == bool(mem[_1045])
if not mem[_1045]:
revert with 0, 'PresenceClaim: _safeMint: CID has not been validated!'
_1052 = mem[64]
mem[64] = mem[64] + 32
mem[_1052] = 0
if not addr(_1035):
revert with 0, 'ERC721: mint to the zero address'
if 1 == addr(ownerOf[cd].field_0):
if 1 == addr(ownerOf[cd].field_0):
balanceOf[addr(_1035)]++
mem[0] = cd[36]
mem[32] = 3
addr(ownerOf[cd].field_0) = addr(_1035)
log Transfer(
address from=0,
address to=addr(_1035),
uint256 tokens=cd
if ext_code.size(addr(_1035)):
mem[mem[64] + 4] = caller
mem[mem[64] + 36] = 0
mem[mem[64] + 68] = cd[36]
mem[mem[64] + 100] = 128
mem[mem[64] + 132] = 0
mem[mem[64] + 164 len 0] = None
call addr(_1035).onERC721Received(address operator, address from, uint256 childTokenId, bytes data) with:
gas gas_remaining wei
args caller, 0, cd[36], 128, 0
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
if not return_data.size:
if not -mem[96]:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with memory
from 128
len mem[96]
if not -return_data.size:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with ext_call.return_data[0 len return_data.size]
_1388 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_1388] == Mask(32, 224, mem[_1388])
if Mask(32, 224, mem[_1388]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
else:
if addr(ownerOf[cd].field_0):
revert with 0, 'ERC721: token already minted'
balanceOf[addr(_1035)]++
mem[0] = cd[36]
mem[32] = 3
addr(ownerOf[cd].field_0) = addr(_1035)
log Transfer(
address from=0,
address to=addr(_1035),
uint256 tokens=cd
if ext_code.size(addr(_1035)):
mem[mem[64] + 4] = caller
mem[mem[64] + 36] = 0
mem[mem[64] + 68] = cd[36]
mem[mem[64] + 100] = 128
mem[mem[64] + 132] = 0
mem[mem[64] + 164 len 0] = None
call addr(_1035).onERC721Received(address operator, address from, uint256 childTokenId, bytes data) with:
gas gas_remaining wei
args caller, 0, cd[36], 128, 0
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
if not return_data.size:
if not -mem[96]:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with memory
from 128
len mem[96]
if not -return_data.size:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with ext_call.return_data[0 len return_data.size]
_1390 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_1390] == Mask(32, 224, mem[_1390])
if Mask(32, 224, mem[_1390]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
else:
if addr(ownerOf[cd].field_0):
revert with 0, 'ERC721: token already minted'
if 1 == addr(ownerOf[cd].field_0):
balanceOf[addr(_1035)]++
mem[0] = cd[36]
mem[32] = 3
addr(ownerOf[cd].field_0) = addr(_1035)
log Transfer(
address from=0,
address to=addr(_1035),
uint256 tokens=cd
if ext_code.size(addr(_1035)):
mem[mem[64] + 4] = caller
mem[mem[64] + 36] = 0
mem[mem[64] + 68] = cd[36]
mem[mem[64] + 100] = 128
mem[mem[64] + 132] = 0
mem[mem[64] + 164 len 0] = None
call addr(_1035).onERC721Received(address operator, address from, uint256 childTokenId, bytes data) with:
gas gas_remaining wei
args caller, 0, cd[36], 128, 0
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
if not return_data.size:
if not -mem[96]:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with memory
from 128
len mem[96]
if not -return_data.size:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with ext_call.return_data[0 len return_data.size]
_1392 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_1392] == Mask(32, 224, mem[_1392])
if Mask(32, 224, mem[_1392]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
else:
if addr(ownerOf[cd].field_0):
revert with 0, 'ERC721: token already minted'
balanceOf[addr(_1035)]++
mem[0] = cd[36]
mem[32] = 3
addr(ownerOf[cd].field_0) = addr(_1035)
log Transfer(
address from=0,
address to=addr(_1035),
uint256 tokens=cd
if ext_code.size(addr(_1035)):
mem[mem[64] + 4] = caller
mem[mem[64] + 36] = 0
mem[mem[64] + 68] = cd[36]
mem[mem[64] + 100] = 128
mem[mem[64] + 132] = 0
mem[mem[64] + 164 len 0] = None
call addr(_1035).onERC721Received(address operator, address from, uint256 childTokenId, bytes data) with:
gas gas_remaining wei
args caller, 0, cd[36], 128, 0
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
if not return_data.size:
if not -mem[96]:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with memory
from 128
len mem[96]
if not -return_data.size:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with ext_call.return_data[0 len return_data.size]
_1394 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_1394] == Mask(32, 224, mem[_1394])
if Mask(32, 224, mem[_1394]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
def unknown20de52b2(uint256 _param1) payable:
require calldata.size - 4 >=′ 32
static call unknown660c4af3Address.0x5558f555 with:
gas gas_remaining wei
mem[96] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
require return_data.size >=′ 32
require ext_call.return_data == ext_call.return_data[12 len 20]
mem[ceil32(return_data.size) + 96] = 0xb5f951bd00000000000000000000000000000000000000000000000000000000
mem[ceil32(return_data.size) + 100] = _param1
static call addr(ext_call.return_data).0xb5f951bd with:
gas gas_remaining wei
args _param1
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
mem[ceil32(return_data.size) + 96 len return_data.size] = ext_call.return_data[0 len return_data.size]
require return_data.size >=′ 32
_8 = mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32
require mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32 <= 18446744073709551615
require return_data.size - mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32 >=′ 320
if not bool((2 * ceil32(return_data.size)) + 416 <= 18446744073709551615):
revert with 'NH{q', 65
mem[64] = (2 * ceil32(return_data.size)) + 416
mem[(2 * ceil32(return_data.size)) + 96] = mem[ceil32(return_data.size) + mem[ceil32(return_data.size) + 96 len 4], Mask(224, 32, _param1) >> 32 + 96]
mem[(2 * ceil32(return_data.size)) + 128] = mem[ceil32(return_data.size) + _8 + 128]
require mem[ceil32(return_data.size) + _8 + 160] == mem[ceil32(return_data.size) + _8 + 180 len 12]
mem[(2 * ceil32(return_data.size)) + 160] = mem[ceil32(return_data.size) + _8 + 160]
require mem[ceil32(return_data.size) + _8 + 192] == Mask(160, 96, mem[ceil32(return_data.size) + _8 + 192])
mem[(2 * ceil32(return_data.size)) + 192] = mem[ceil32(return_data.size) + _8 + 192]
require mem[ceil32(return_data.size) + _8 + 224] == mem[ceil32(return_data.size) + _8 + 236 len 20]
mem[(2 * ceil32(return_data.size)) + 224] = mem[ceil32(return_data.size) + _8 + 224]
require mem[ceil32(return_data.size) + _8 + 256] == mem[ceil32(return_data.size) + _8 + 276 len 12]
mem[(2 * ceil32(return_data.size)) + 256] = mem[ceil32(return_data.size) + _8 + 256]
require mem[ceil32(return_data.size) + _8 + 288] == mem[ceil32(return_data.size) + _8 + 316 len 4]
mem[(2 * ceil32(return_data.size)) + 288] = mem[ceil32(return_data.size) + _8 + 288]
require mem[ceil32(return_data.size) + _8 + 320] == mem[ceil32(return_data.size) + _8 + 351 len 1]
mem[(2 * ceil32(return_data.size)) + 320] = mem[ceil32(return_data.size) + _8 + 320]
require mem[ceil32(return_data.size) + _8 + 352] == mem[ceil32(return_data.size) + _8 + 383 len 1]
mem[(2 * ceil32(return_data.size)) + 352] = mem[ceil32(return_data.size) + _8 + 352]
_19 = mem[ceil32(return_data.size) + _8 + 384]
require mem[ceil32(return_data.size) + _8 + 384] <= 18446744073709551615
require ceil32(return_data.size) + _8 + mem[ceil32(return_data.size) + _8 + 384] + 127 <′ ceil32(return_data.size) + return_data.size + 96
_20 = mem[ceil32(return_data.size) + _8 + mem[ceil32(return_data.size) + _8 + 384] + 96]
if mem[ceil32(return_data.size) + _8 + mem[ceil32(return_data.size) + _8 + 384] + 96] > 18446744073709551615:
revert with 'NH{q', 65
if ceil32(ceil32(mem[ceil32(return_data.size) + _8 + mem[ceil32(return_data.size) + _8 + 384] + 96])) + 321 < 320 or (2 * ceil32(return_data.size)) + ceil32(ceil32(mem[ceil32(return_data.size) + _8 + mem[ceil32(return_data.size) + _8 + 384] + 96])) + 417 > 18446744073709551615:
revert with 'NH{q', 65
mem[64] = (2 * ceil32(return_data.size)) + ceil32(ceil32(mem[ceil32(return_data.size) + _8 + mem[ceil32(return_data.size) + _8 + 384] + 96])) + 417
mem[(2 * ceil32(return_data.size)) + 416] = _20
require _8 + _19 + _20 + 32 <= return_data.size
mem[(2 * ceil32(return_data.size)) + 448 len ceil32(_20)] = mem[ceil32(return_data.size) + _8 + _19 + 128 len ceil32(_20)]
if ceil32(_20) <= _20:
mem[(2 * ceil32(return_data.size)) + 384] = (2 * ceil32(return_data.size)) + 416
_384 = mem[(2 * ceil32(return_data.size)) + 224]
static call unknown660c4af3Address.0x3d25049 with:
gas gas_remaining wei
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_390 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
_392 = mem[_390]
require mem[_390] == mem[_390 + 12 len 20]
_394 = mem[(2 * ceil32(return_data.size)) + 128]
mem[mem[64] + 4] = mem[(2 * ceil32(return_data.size)) + 128]
static call addr(_392).ownerOf(uint256 deedId) with:
gas gas_remaining wei
args _394
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_400 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
_402 = mem[_400]
require mem[_400] == mem[_400 + 12 len 20]
_404 = mem[(2 * ceil32(return_data.size)) + 256]
static call unknown660c4af3Address.0x3d25049 with:
gas gas_remaining wei
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_410 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_410] == mem[_410 + 12 len 20]
static call mem[_410 + 12 len 20].0xac846501 with:
gas gas_remaining wei
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_418 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
_420 = mem[_418]
require mem[_418] == mem[_418 + 12 len 20]
mem[mem[64] + 4] = addr(_384)
mem[mem[64] + 36] = addr(_402)
mem[mem[64] + 68] = Mask(96, 0, _404)
call addr(_420).transferFrom(address from, address to, uint256 tokens) with:
gas gas_remaining wei
args addr(_384), addr(_402), Mask(96, 0, _404)
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_426 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_426] == bool(mem[_426])
mem[mem[64] + 4] = _param1
static call unknown660c4af3Address.0xce6915fa with:
gas gas_remaining wei
args _param1
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_434 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_434] == bool(mem[_434])
if not mem[_434]:
revert with 0, 'PresenceClaim: _safeMint: CID has not been validated!'
_440 = mem[64]
mem[64] = mem[64] + 32
mem[_440] = 0
if not addr(_384):
revert with 0, 'ERC721: mint to the zero address'
if 1 == addr(ownerOf[_param1].field_0):
if 1 == addr(ownerOf[_param1].field_0):
balanceOf[addr(_384)]++
mem[0] = _param1
mem[32] = 3
addr(ownerOf[_param1].field_0) = addr(_384)
log Transfer(
address from=0,
address to=addr(_384),
uint256 tokens=_param1)
if ext_code.size(addr(_384)):
mem[mem[64] + 4] = caller
mem[mem[64] + 36] = 0
mem[mem[64] + 68] = _param1
mem[mem[64] + 100] = 128
mem[mem[64] + 132] = 0
mem[mem[64] + 164 len 0] = None
call addr(_384).onERC721Received(address operator, address from, uint256 childTokenId, bytes data) with:
gas gas_remaining wei
args caller, 0, _param1, 128, 0
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
if not return_data.size:
if not -ext_call.return_data[0]:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with memory
from 128
len ext_call.return_data[0]
if not -return_data.size:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with ext_call.return_data[0 len return_data.size]
_768 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_768] == Mask(32, 224, mem[_768])
if Mask(32, 224, mem[_768]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
else:
if addr(ownerOf[_param1].field_0):
revert with 0, 'ERC721: token already minted'
balanceOf[addr(_384)]++
mem[0] = _param1
mem[32] = 3
addr(ownerOf[_param1].field_0) = addr(_384)
log Transfer(
address from=0,
address to=addr(_384),
uint256 tokens=_param1)
if ext_code.size(addr(_384)):
mem[mem[64] + 4] = caller
mem[mem[64] + 36] = 0
mem[mem[64] + 68] = _param1
mem[mem[64] + 100] = 128
mem[mem[64] + 132] = 0
mem[mem[64] + 164 len 0] = None
call addr(_384).onERC721Received(address operator, address from, uint256 childTokenId, bytes data) with:
gas gas_remaining wei
args caller, 0, _param1, 128, 0
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
if not return_data.size:
if not -ext_call.return_data[0]:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with memory
from 128
len ext_call.return_data[0]
if not -return_data.size:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with ext_call.return_data[0 len return_data.size]
_770 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_770] == Mask(32, 224, mem[_770])
if Mask(32, 224, mem[_770]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
else:
if addr(ownerOf[_param1].field_0):
revert with 0, 'ERC721: token already minted'
if 1 == addr(ownerOf[_param1].field_0):
balanceOf[addr(_384)]++
mem[0] = _param1
mem[32] = 3
addr(ownerOf[_param1].field_0) = addr(_384)
log Transfer(
address from=0,
address to=addr(_384),
uint256 tokens=_param1)
if ext_code.size(addr(_384)):
mem[mem[64] + 4] = caller
mem[mem[64] + 36] = 0
mem[mem[64] + 68] = _param1
mem[mem[64] + 100] = 128
mem[mem[64] + 132] = 0
mem[mem[64] + 164 len 0] = None
call addr(_384).onERC721Received(address operator, address from, uint256 childTokenId, bytes data) with:
gas gas_remaining wei
args caller, 0, _param1, 128, 0
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
if not return_data.size:
if not -ext_call.return_data[0]:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with memory
from 128
len ext_call.return_data[0]
if not -return_data.size:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with ext_call.return_data[0 len return_data.size]
_772 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_772] == Mask(32, 224, mem[_772])
if Mask(32, 224, mem[_772]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
else:
if addr(ownerOf[_param1].field_0):
revert with 0, 'ERC721: token already minted'
balanceOf[addr(_384)]++
mem[0] = _param1
mem[32] = 3
addr(ownerOf[_param1].field_0) = addr(_384)
log Transfer(
address from=0,
address to=addr(_384),
uint256 tokens=_param1)
if ext_code.size(addr(_384)):
mem[mem[64] + 4] = caller
mem[mem[64] + 36] = 0
mem[mem[64] + 68] = _param1
mem[mem[64] + 100] = 128
mem[mem[64] + 132] = 0
mem[mem[64] + 164 len 0] = None
call addr(_384).onERC721Received(address operator, address from, uint256 childTokenId, bytes data) with:
gas gas_remaining wei
args caller, 0, _param1, 128, 0
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
if not return_data.size:
if not -ext_call.return_data[0]:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with memory
from 128
len ext_call.return_data[0]
if not -return_data.size:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with ext_call.return_data[0 len return_data.size]
_774 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_774] == Mask(32, 224, mem[_774])
if Mask(32, 224, mem[_774]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
else:
mem[_20 + (2 * ceil32(return_data.size)) + 448] = 0
mem[(2 * ceil32(return_data.size)) + 384] = (2 * ceil32(return_data.size)) + 416
_387 = mem[(2 * ceil32(return_data.size)) + 224]
static call unknown660c4af3Address.0x3d25049 with:
gas gas_remaining wei
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_391 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
_393 = mem[_391]
require mem[_391] == mem[_391 + 12 len 20]
_396 = mem[(2 * ceil32(return_data.size)) + 128]
mem[mem[64] + 4] = mem[(2 * ceil32(return_data.size)) + 128]
static call addr(_393).ownerOf(uint256 deedId) with:
gas gas_remaining wei
args _396
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_401 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
_403 = mem[_401]
require mem[_401] == mem[_401 + 12 len 20]
_407 = mem[(2 * ceil32(return_data.size)) + 256]
static call unknown660c4af3Address.0x3d25049 with:
gas gas_remaining wei
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_411 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_411] == mem[_411 + 12 len 20]
static call mem[_411 + 12 len 20].0xac846501 with:
gas gas_remaining wei
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_419 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
_421 = mem[_419]
require mem[_419] == mem[_419 + 12 len 20]
mem[mem[64] + 4] = addr(_387)
mem[mem[64] + 36] = addr(_403)
mem[mem[64] + 68] = Mask(96, 0, _407)
call addr(_421).transferFrom(address from, address to, uint256 tokens) with:
gas gas_remaining wei
args addr(_387), addr(_403), Mask(96, 0, _407)
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_427 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_427] == bool(mem[_427])
mem[mem[64] + 4] = _param1
static call unknown660c4af3Address.0xce6915fa with:
gas gas_remaining wei
args _param1
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_435 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_435] == bool(mem[_435])
if not mem[_435]:
revert with 0, 'PresenceClaim: _safeMint: CID has not been validated!'
_442 = mem[64]
mem[64] = mem[64] + 32
mem[_442] = 0
if not addr(_387):
revert with 0, 'ERC721: mint to the zero address'
if 1 == addr(ownerOf[_param1].field_0):
if 1 == addr(ownerOf[_param1].field_0):
balanceOf[addr(_387)]++
mem[0] = _param1
mem[32] = 3
addr(ownerOf[_param1].field_0) = addr(_387)
log Transfer(
address from=0,
address to=addr(_387),
uint256 tokens=_param1)
if ext_code.size(addr(_387)):
mem[mem[64] + 4] = caller
mem[mem[64] + 36] = 0
mem[mem[64] + 68] = _param1
mem[mem[64] + 100] = 128
mem[mem[64] + 132] = 0
mem[mem[64] + 164 len 0] = None
call addr(_387).onERC721Received(address operator, address from, uint256 childTokenId, bytes data) with:
gas gas_remaining wei
args caller, 0, _param1, 128, 0
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
if not return_data.size:
if not -ext_call.return_data[0]:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with memory
from 128
len ext_call.return_data[0]
if not -return_data.size:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with ext_call.return_data[0 len return_data.size]
_776 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_776] == Mask(32, 224, mem[_776])
if Mask(32, 224, mem[_776]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
else:
if addr(ownerOf[_param1].field_0):
revert with 0, 'ERC721: token already minted'
balanceOf[addr(_387)]++
mem[0] = _param1
mem[32] = 3
addr(ownerOf[_param1].field_0) = addr(_387)
log Transfer(
address from=0,
address to=addr(_387),
uint256 tokens=_param1)
if ext_code.size(addr(_387)):
mem[mem[64] + 4] = caller
mem[mem[64] + 36] = 0
mem[mem[64] + 68] = _param1
mem[mem[64] + 100] = 128
mem[mem[64] + 132] = 0
mem[mem[64] + 164 len 0] = None
call addr(_387).onERC721Received(address operator, address from, uint256 childTokenId, bytes data) with:
gas gas_remaining wei
args caller, 0, _param1, 128, 0
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
if not return_data.size:
if not -ext_call.return_data[0]:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with memory
from 128
len ext_call.return_data[0]
if not -return_data.size:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with ext_call.return_data[0 len return_data.size]
_778 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_778] == Mask(32, 224, mem[_778])
if Mask(32, 224, mem[_778]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
else:
if addr(ownerOf[_param1].field_0):
revert with 0, 'ERC721: token already minted'
if 1 == addr(ownerOf[_param1].field_0):
balanceOf[addr(_387)]++
mem[0] = _param1
mem[32] = 3
addr(ownerOf[_param1].field_0) = addr(_387)
log Transfer(
address from=0,
address to=addr(_387),
uint256 tokens=_param1)
if ext_code.size(addr(_387)):
mem[mem[64] + 4] = caller
mem[mem[64] + 36] = 0
mem[mem[64] + 68] = _param1
mem[mem[64] + 100] = 128
mem[mem[64] + 132] = 0
mem[mem[64] + 164 len 0] = None
call addr(_387).onERC721Received(address operator, address from, uint256 childTokenId, bytes data) with:
gas gas_remaining wei
args caller, 0, _param1, 128, 0
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
if not return_data.size:
if not -ext_call.return_data[0]:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with memory
from 128
len ext_call.return_data[0]
if not -return_data.size:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with ext_call.return_data[0 len return_data.size]
_780 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_780] == Mask(32, 224, mem[_780])
if Mask(32, 224, mem[_780]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
else:
if addr(ownerOf[_param1].field_0):
revert with 0, 'ERC721: token already minted'
balanceOf[addr(_387)]++
mem[0] = _param1
mem[32] = 3
addr(ownerOf[_param1].field_0) = addr(_387)
log Transfer(
address from=0,
address to=addr(_387),
uint256 tokens=_param1)
if ext_code.size(addr(_387)):
mem[mem[64] + 4] = caller
mem[mem[64] + 36] = 0
mem[mem[64] + 68] = _param1
mem[mem[64] + 100] = 128
mem[mem[64] + 132] = 0
mem[mem[64] + 164 len 0] = None
call addr(_387).onERC721Received(address operator, address from, uint256 childTokenId, bytes data) with:
gas gas_remaining wei
args caller, 0, _param1, 128, 0
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
if not return_data.size:
if not -ext_call.return_data[0]:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with memory
from 128
len ext_call.return_data[0]
if not -return_data.size:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
revert with ext_call.return_data[0 len return_data.size]
_782 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_782] == Mask(32, 224, mem[_782])
if Mask(32, 224, mem[_782]) != 0x150b7a0200000000000000000000000000000000000000000000000000000000:
revert with 0, 'ERC721: transfer to non ERC721Receiver implementer'
def unknown5d5bee58() payable:
require calldata.size - 4 >=′ 96
require cd <= 18446744073709551615
require cd <′ calldata.size
if ('cd', 36).length > 18446744073709551615:
revert with 'NH{q', 65
if ceil32(ceil32(('cd', 36).length)) + 97 < 96 or ceil32(ceil32(('cd', 36).length)) + 97 > 18446744073709551615:
revert with 'NH{q', 65
mem[96] = ('cd', 36).length
require cd('cd', 36).length + 36 <= calldata.size
mem[128 len ('cd', 36).length] = call.data[cd('cd', 36).length]
mem[('cd', 36).length + 128] = 0
require cd <= 18446744073709551615
require cd <′ calldata.size
if ('cd', 68).length > 18446744073709551615:
revert with 'NH{q', 65
if ceil32(32 * ('cd', 68).length) + 98 < 97 or ceil32(ceil32(('cd', 36).length)) + ceil32(32 * ('cd', 68).length) + 98 > 18446744073709551615:
revert with 'NH{q', 65
mem[64] = ceil32(ceil32(('cd', 36).length)) + ceil32(32 * ('cd', 68).length) + 98
mem[ceil32(ceil32(('cd', 36).length)) + 97] = ('cd', 68).length
require (32 * ('cd', 68).length) + cd <= calldata.size
s = ceil32(ceil32(('cd', 36).length)) + 129
idx = cd[68] + 36
while idx < (32 * ('cd', 68).length) + cd:
require cd[idx] <= 18446744073709551615
require cdidx] + 67 <′ calldata.size
if cd[(cdidx] + 36)] > 18446744073709551615:
revert with 'NH{q', 65
_783 = mem[64]
if mem[64] + ceil32(ceil32(cd[(cdidx] + 36)])) + 1 < mem[64] or mem[64] + ceil32(ceil32(cd[(cdidx] + 36)])) + 1 > 18446744073709551615:
revert with 'NH{q', 65
mem[64] = mem[64] + ceil32(ceil32(cd[(cdidx] + 36)])) + 1
mem[_783] = cd[(cdidx] + 36)]
require cdidx] + cd[(cdidx] + 36)] + 68 <= calldata.size
mem[_783 + 32 len cd[(cdidx] + 36)]] = call.data[cdidx] + 68 len cd[(cdidx] + 36)]]
mem[_783 + cd[(cdidx] + 36)] + 32] = 0
mem[s] = _783
s = s + 32
idx = idx + 32
continue
_781 = mem[64]
mem[mem[64]] = 0x929d98f100000000000000000000000000000000000000000000000000000000
mem[mem[64] + 4] = cd[4]
mem[mem[64] + 36] = 96
_782 = mem[96]
mem[mem[64] + 100] = mem[96]
mem[mem[64] + 132 len ceil32(mem[96])] = mem[128 len ceil32(mem[96])]
if ceil32(mem[96]) <= mem[96]:
mem[mem[64] + 68] = ceil32(mem[96]) + 128
_1560 = mem[ceil32(ceil32(('cd', 36).length)) + 97]
mem[ceil32(mem[96]) + mem[64] + 132] = mem[ceil32(ceil32(('cd', 36).length)) + 97]
idx = 0
s = ceil32(ceil32(('cd', 36).length)) + 129
t = ceil32(mem[96]) + mem[64] + (32 * _1560) + 164
u = ceil32(mem[96]) + mem[64] + 164
while idx < _1560:
mem[u] = t + -ceil32(_782) + -_781 - 164
_2334 = mem[s]
_2337 = mem[mem[s]]
mem[t] = mem[mem[s]]
v = 0
while v < _2337:
mem[v + t + 32] = mem[v + _2334 + 32]
v = v + 32
continue
if ceil32(_2337) > _2337:
mem[_2337 + t + 32] = 0
idx = idx + 1
s = s + 32
t = ceil32(_2337) + t + 32
u = u + 32
continue
require ext_code.size(unknown660c4af3Address)
call unknown660c4af3Address.mem[mem[64] len 4] with:
gas gas_remaining wei
args mem[mem[64] + 4 len t + -mem[64] - 4]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
static call unknown660c4af3Address.0x5558f555 with:
gas gas_remaining wei
mem[mem[64]] = ext_call.return_data[0]
_2346 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
_2348 = mem[_2346]
require mem[_2346] == mem[_2346 + 12 len 20]
mem[mem[64]] = 0xb5f951bd00000000000000000000000000000000000000000000000000000000
mem[mem[64] + 4] = cd[4]
static call addr(_2348).0xb5f951bd with:
gas gas_remaining wei
args cd[4]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_2354 = mem[64]
mem[mem[64] len return_data.size] = ext_call.return_data[0 len return_data.size]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
_2356 = mem[_2354]
require mem[_2354] <= 18446744073709551615
require return_data.size - mem[_2354] >=′ 320
if not bool(_2354 + ceil32(return_data.size) + 320 <= 18446744073709551615):
revert with 'NH{q', 65
mem[64] = _2354 + ceil32(return_data.size) + 320
mem[_2354 + ceil32(return_data.size)] = mem[_2354 + _2356]
mem[_2354 + ceil32(return_data.size) + 32] = mem[_2354 + _2356 + 32]
require mem[_2354 + _2356 + 64] == mem[_2354 + _2356 + 84 len 12]
mem[_2354 + ceil32(return_data.size) + 64] = mem[_2354 + _2356 + 64]
require mem[_2354 + _2356 + 96] == Mask(160, 96, mem[_2354 + _2356 + 96])
mem[_2354 + ceil32(return_data.size) + 96] = mem[_2354 + _2356 + 96]
require mem[_2354 + _2356 + 128] == mem[_2354 + _2356 + 140 len 20]
mem[_2354 + ceil32(return_data.size) + 128] = mem[_2354 + _2356 + 128]
require mem[_2354 + _2356 + 160] == mem[_2354 + _2356 + 180 len 12]
mem[_2354 + ceil32(return_data.size) + 160] = mem[_2354 + _2356 + 160]
require mem[_2354 + _2356 + 192] == mem[_2354 + _2356 + 220 len 4]
mem[_2354 + ceil32(return_data.size) + 192] = mem[_2354 + _2356 + 192]
require mem[_2354 + _2356 + 224] == mem[_2354 + _2356 + 255 len 1]
mem[_2354 + ceil32(return_data.size) + 224] = mem[_2354 + _2356 + 224]
require mem[_2354 + _2356 + 256] == mem[_2354 + _2356 + 287 len 1]
mem[_2354 + ceil32(return_data.size) + 256] = mem[_2354 + _2356 + 256]
_2378 = mem[_2354 + _2356 + 288]
require mem[_2354 + _2356 + 288] <= 18446744073709551615
require _2354 + _2356 + mem[_2354 + _2356 + 288] + 31 <′ _2354 + return_data.size
_2380 = mem[_2354 + _2356 + mem[_2354 + _2356 + 288]]
if mem[_2354 + _2356 + mem[_2354 + _2356 + 288]] > 18446744073709551615:
revert with 'NH{q', 65
if ceil32(ceil32(mem[_2354 + _2356 + mem[_2354 + _2356 + 288]])) + 321 < 320 or _2354 + ceil32(return_data.size) + ceil32(ceil32(mem[_2354 + _2356 + mem[_2354 + _2356 + 288]])) + 321 > 18446744073709551615:
revert with 'NH{q', 65
mem[64] = _2354 + ceil32(return_data.size) + ceil32(ceil32(mem[_2354 + _2356 + mem[_2354 + _2356 + 288]])) + 321
mem[_2354 + ceil32(return_data.size) + 320] = _2380
require _2356 + _2378 + _2380 + 32 <= return_data.size
mem[_2354 + ceil32(return_data.size) + 352 len ceil32(_2380)] = mem[_2354 + _2356 + _2378 + 32 len ceil32(_2380)]
if ceil32(_2380) <= _2380:
mem[_2354 + ceil32(return_data.size) + 288] = _2354 + ceil32(return_data.size) + 320
_3110 = mem[_2354 + ceil32(return_data.size) + 128]
static call unknown660c4af3Address.0x3d25049 with:
gas gas_remaining wei
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_3122 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
_3126 = mem[_3122]
require mem[_3122] == mem[_3122 + 12 len 20]
_3130 = mem[_2354 + ceil32(return_data.size) + 32]
mem[mem[64] + 4] = mem[_2354 + ceil32(return_data.size) + 32]
static call addr(_3126).ownerOf(uint256 deedId) with:
gas gas_remaining wei
args _3130
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_3142 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
_3146 = mem[_3142]
require mem[_3142] == mem[_3142 + 12 len 20]
_3150 = mem[_2354 + ceil32(return_data.size) + 160]
static call unknown660c4af3Address.0x3d25049 with:
gas gas_remaining wei
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_3162 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_3162] == mem[_3162 + 12 len 20]
static call mem[_3162 + 12 len 20].0xac846501 with:
gas gas_remaining wei
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_3178 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
_3182 = mem[_3178]
require mem[_3178] == mem[_3178 + 12 len 20]
mem[mem[64] + 4] = addr(_3110)
mem[mem[64] + 36] = addr(_3146)
mem[mem[64] + 68] = Mask(96, 0, _3150)
call addr(_3182).transferFrom(address from, address to, uint256 tokens) with:
gas gas_remaining wei
args addr(_3110), addr(_3146), Mask(96, 0, _3150)
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_3194 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_3194] == bool(mem[_3194])
mem[mem[64] + 4] = cd[4]
static call unknown660c4af3Address.0xce6915fa with:
gas gas_remaining wei
args cd[4]
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_3210 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_3210] == bool(mem[_3210])
if not mem[_3210]:
revert with 0, 'PresenceClaim: _safeMint: CID has not been validated!'
if not addr(_3110):
revert with 0, 'ERC721: mint to the zero address'
if addr(ownerOf[cd].field_0) != 1:
if addr(ownerOf[cd].field_0):
revert with 0, 'ERC721: token already minted'
if addr(ownerOf[cd].field_0) != 1:
if addr(ownerOf[cd].field_0):
revert with 0, 'ERC721: token already minted'
balanceOf[addr(_3110)]++
addr(ownerOf[cd].field_0) = addr(_3110)
log Transfer(
address from=0,
address to=addr(_3110),
uint256 tokens=cd
if not ext_code.size(addr(_3110)):
stop
else:
mem[_2380 + _2354 + ceil32(return_data.size) + 352] = 0
mem[_2354 + ceil32(return_data.size) + 288] = _2354 + ceil32(return_data.size) + 320
_3113 = mem[_2354 + ceil32(return_data.size) + 128]
static call unknown660c4af3Address.0x3d25049 with:
gas gas_remaining wei
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_3123 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
_3127 = mem[_3123]
require mem[_3123] == mem[_3123 + 12 len 20]
_3132 = mem[_2354 + ceil32(return_data.size) + 32]
mem[mem[64] + 4] = mem[_2354 + ceil32(return_data.size) + 32]
static call addr(_3127).ownerOf(uint256 deedId) with:
gas gas_remaining wei
args _3132
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_3143 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
_3147 = mem[_3143]
require mem[_3143] == mem[_3143 + 12 len 20]
_3153 = mem[_2354 + ceil32(return_data.size) + 160]
static call unknown660c4af3Address.0x3d25049 with:
gas gas_remaining wei
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_3163 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_3163] == mem[_3163 + 12 len 20]
static call mem[_3163 + 12 len 20].0xac846501 with:
gas gas_remaining wei
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_3179 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
_3183 = mem[_3179]
require mem[_3179] == mem[_3179 + 12 len 20]
mem[mem[64] + 4] = addr(_3113)
mem[mem[64] + 36] = addr(_3147)
mem[mem[64] + 68] = Mask(96, 0, _3153)
call addr(_3183).transferFrom(address from, address to, uint256 tokens) with:
gas gas_remaining wei
args addr(_3113), addr(_3147), Mask(96, 0, _3153)
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_3195 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_3195] == bool(mem[_3195])
mem[mem[64] + 4] = cd[4]
static call unknown660c4af3Address.0xce6915fa with:
gas gas_remaining wei
args cd[4]
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_3211 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_3211] == bool(mem[_3211])
if not mem[_3211]:
revert with 0, 'PresenceClaim: _safeMint: CID has not been validated!'
if not addr(_3113):
revert with 0, 'ERC721: mint to the zero address'
if addr(ownerOf[cd].field_0) != 1:
if addr(ownerOf[cd].field_0):
revert with 0, 'ERC721: token already minted'
if addr(ownerOf[cd].field_0) != 1:
if addr(ownerOf[cd].field_0):
revert with 0, 'ERC721: token already minted'
balanceOf[addr(_3113)]++
addr(ownerOf[cd].field_0) = addr(_3113)
log Transfer(
address from=0,
address to=addr(_3113),
uint256 tokens=cd
if not ext_code.size(addr(_3113)):
stop
else:
mem[mem[96] + mem[64] + 132] = 0
mem[mem[64] + 68] = ceil32(mem[96]) + 128
_1561 = mem[ceil32(ceil32(('cd', 36).length)) + 97]
mem[ceil32(mem[96]) + _781 + 132] = mem[ceil32(ceil32(('cd', 36).length)) + 97]
idx = 0
s = ceil32(ceil32(('cd', 36).length)) + 129
t = ceil32(mem[96]) + _781 + (32 * _1561) + 164
u = ceil32(mem[96]) + _781 + 164
while idx < _1561:
mem[u] = t + -ceil32(_782) + -_781 - 164
_2335 = mem[s]
_2339 = mem[mem[s]]
mem[t] = mem[mem[s]]
v = 0
while v < _2339:
mem[v + t + 32] = mem[v + _2335 + 32]
v = v + 32
continue
if ceil32(_2339) > _2339:
mem[_2339 + t + 32] = 0
idx = idx + 1
s = s + 32
t = ceil32(_2339) + t + 32
u = u + 32
continue
require ext_code.size(unknown660c4af3Address)
call unknown660c4af3Address.mem[mem[64] len 4] with:
gas gas_remaining wei
args mem[mem[64] + 4 len t + -mem[64] - 4]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
static call unknown660c4af3Address.0x5558f555 with:
gas gas_remaining wei
mem[mem[64]] = ext_call.return_data[0]
_2347 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
_2349 = mem[_2347]
require mem[_2347] == mem[_2347 + 12 len 20]
mem[mem[64]] = 0xb5f951bd00000000000000000000000000000000000000000000000000000000
mem[mem[64] + 4] = cd[4]
static call addr(_2349).0xb5f951bd with:
gas gas_remaining wei
args cd[4]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_2355 = mem[64]
mem[mem[64] len return_data.size] = ext_call.return_data[0 len return_data.size]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
_2357 = mem[_2355]
require mem[_2355] <= 18446744073709551615
require return_data.size - mem[_2355] >=′ 320
if not bool(_2355 + ceil32(return_data.size) + 320 <= 18446744073709551615):
revert with 'NH{q', 65
mem[64] = _2355 + ceil32(return_data.size) + 320
mem[_2355 + ceil32(return_data.size)] = mem[_2355 + _2357]
mem[_2355 + ceil32(return_data.size) + 32] = mem[_2355 + _2357 + 32]
require mem[_2355 + _2357 + 64] == mem[_2355 + _2357 + 84 len 12]
mem[_2355 + ceil32(return_data.size) + 64] = mem[_2355 + _2357 + 64]
require mem[_2355 + _2357 + 96] == Mask(160, 96, mem[_2355 + _2357 + 96])
mem[_2355 + ceil32(return_data.size) + 96] = mem[_2355 + _2357 + 96]
require mem[_2355 + _2357 + 128] == mem[_2355 + _2357 + 140 len 20]
mem[_2355 + ceil32(return_data.size) + 128] = mem[_2355 + _2357 + 128]
require mem[_2355 + _2357 + 160] == mem[_2355 + _2357 + 180 len 12]
mem[_2355 + ceil32(return_data.size) + 160] = mem[_2355 + _2357 + 160]
require mem[_2355 + _2357 + 192] == mem[_2355 + _2357 + 220 len 4]
mem[_2355 + ceil32(return_data.size) + 192] = mem[_2355 + _2357 + 192]
require mem[_2355 + _2357 + 224] == mem[_2355 + _2357 + 255 len 1]
mem[_2355 + ceil32(return_data.size) + 224] = mem[_2355 + _2357 + 224]
require mem[_2355 + _2357 + 256] == mem[_2355 + _2357 + 287 len 1]
mem[_2355 + ceil32(return_data.size) + 256] = mem[_2355 + _2357 + 256]
_2379 = mem[_2355 + _2357 + 288]
require mem[_2355 + _2357 + 288] <= 18446744073709551615
require _2355 + _2357 + mem[_2355 + _2357 + 288] + 31 <′ _2355 + return_data.size
_2381 = mem[_2355 + _2357 + mem[_2355 + _2357 + 288]]
if mem[_2355 + _2357 + mem[_2355 + _2357 + 288]] > 18446744073709551615:
revert with 'NH{q', 65
if ceil32(ceil32(mem[_2355 + _2357 + mem[_2355 + _2357 + 288]])) + 321 < 320 or _2355 + ceil32(return_data.size) + ceil32(ceil32(mem[_2355 + _2357 + mem[_2355 + _2357 + 288]])) + 321 > 18446744073709551615:
revert with 'NH{q', 65
mem[64] = _2355 + ceil32(return_data.size) + ceil32(ceil32(mem[_2355 + _2357 + mem[_2355 + _2357 + 288]])) + 321
mem[_2355 + ceil32(return_data.size) + 320] = _2381
require _2357 + _2379 + _2381 + 32 <= return_data.size
mem[_2355 + ceil32(return_data.size) + 352 len ceil32(_2381)] = mem[_2355 + _2357 + _2379 + 32 len ceil32(_2381)]
if ceil32(_2381) <= _2381:
mem[_2355 + ceil32(return_data.size) + 288] = _2355 + ceil32(return_data.size) + 320
_3116 = mem[_2355 + ceil32(return_data.size) + 128]
static call unknown660c4af3Address.0x3d25049 with:
gas gas_remaining wei
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_3124 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
_3128 = mem[_3124]
require mem[_3124] == mem[_3124 + 12 len 20]
_3134 = mem[_2355 + ceil32(return_data.size) + 32]
mem[mem[64] + 4] = mem[_2355 + ceil32(return_data.size) + 32]
static call addr(_3128).ownerOf(uint256 deedId) with:
gas gas_remaining wei
args _3134
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_3144 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
_3148 = mem[_3144]
require mem[_3144] == mem[_3144 + 12 len 20]
_3156 = mem[_2355 + ceil32(return_data.size) + 160]
static call unknown660c4af3Address.0x3d25049 with:
gas gas_remaining wei
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_3164 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_3164] == mem[_3164 + 12 len 20]
static call mem[_3164 + 12 len 20].0xac846501 with:
gas gas_remaining wei
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_3180 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
_3184 = mem[_3180]
require mem[_3180] == mem[_3180 + 12 len 20]
mem[mem[64] + 4] = addr(_3116)
mem[mem[64] + 36] = addr(_3148)
mem[mem[64] + 68] = Mask(96, 0, _3156)
call addr(_3184).transferFrom(address from, address to, uint256 tokens) with:
gas gas_remaining wei
args addr(_3116), addr(_3148), Mask(96, 0, _3156)
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_3196 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_3196] == bool(mem[_3196])
mem[mem[64] + 4] = cd[4]
static call unknown660c4af3Address.0xce6915fa with:
gas gas_remaining wei
args cd[4]
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_3212 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_3212] == bool(mem[_3212])
if not mem[_3212]:
revert with 0, 'PresenceClaim: _safeMint: CID has not been validated!'
if not addr(_3116):
revert with 0, 'ERC721: mint to the zero address'
if addr(ownerOf[cd].field_0) != 1:
if addr(ownerOf[cd].field_0):
revert with 0, 'ERC721: token already minted'
if addr(ownerOf[cd].field_0) != 1:
if addr(ownerOf[cd].field_0):
revert with 0, 'ERC721: token already minted'
balanceOf[addr(_3116)]++
addr(ownerOf[cd].field_0) = addr(_3116)
log Transfer(
address from=0,
address to=addr(_3116),
uint256 tokens=cd
if not ext_code.size(addr(_3116)):
stop
else:
mem[_2381 + _2355 + ceil32(return_data.size) + 352] = 0
mem[_2355 + ceil32(return_data.size) + 288] = _2355 + ceil32(return_data.size) + 320
_3119 = mem[_2355 + ceil32(return_data.size) + 128]
static call unknown660c4af3Address.0x3d25049 with:
gas gas_remaining wei
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_3125 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
_3129 = mem[_3125]
require mem[_3125] == mem[_3125 + 12 len 20]
_3136 = mem[_2355 + ceil32(return_data.size) + 32]
mem[mem[64] + 4] = mem[_2355 + ceil32(return_data.size) + 32]
static call addr(_3129).ownerOf(uint256 deedId) with:
gas gas_remaining wei
args _3136
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_3145 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
_3149 = mem[_3145]
require mem[_3145] == mem[_3145 + 12 len 20]
_3159 = mem[_2355 + ceil32(return_data.size) + 160]
static call unknown660c4af3Address.0x3d25049 with:
gas gas_remaining wei
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_3165 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_3165] == mem[_3165 + 12 len 20]
static call mem[_3165 + 12 len 20].0xac846501 with:
gas gas_remaining wei
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_3181 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
_3185 = mem[_3181]
require mem[_3181] == mem[_3181 + 12 len 20]
mem[mem[64] + 4] = addr(_3119)
mem[mem[64] + 36] = addr(_3149)
mem[mem[64] + 68] = Mask(96, 0, _3159)
call addr(_3185).transferFrom(address from, address to, uint256 tokens) with:
gas gas_remaining wei
args addr(_3119), addr(_3149), Mask(96, 0, _3159)
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_3197 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_3197] == bool(mem[_3197])
mem[mem[64] + 4] = cd[4]
static call unknown660c4af3Address.0xce6915fa with:
gas gas_remaining wei
args cd[4]
mem[mem[64]] = ext_call.return_data[0]
if not ext_call.success:
revert with ext_call.return_data[0 len return_data.size]
_3213 = mem[64]
mem[64] = mem[64] + ceil32(return_data.size)
require return_data.size >=′ 32
require mem[_3213] == bool(mem[_3213])
if not mem[_3213]:
revert with 0, 'PresenceClaim: _safeMint: CID has not been validated!'
if not addr(_3119):
revert with 0, 'ERC721: mint to the zero address'
if addr(ownerOf[cd].field_0) != 1:
if addr(ownerOf[cd].field_0):
revert with 0, 'ERC721: token already minted'
if addr(ownerOf[cd].field_0) != 1:
if addr(ownerOf[cd].field_0):
revert with 0, 'ERC721: token already minted'
balanceOf[addr(_3119)]++
addr(ownerOf[cd].field_0) = addr(_3119)
log Transfer(
address from=0,
address to=addr(_3119),
uint256 tokens=cd
if not ext_code.size(addr(_3119)):
stop
... # Decompilation aborted, sorry: ("decompilation didn't finish",)
def tokenURI(uint256 _tokenId) payable:
require calldata.size - 4 >=′ 32
mem[96] = 66
mem[64] = 224
mem[128 len 66] = call.data[calldata.size len 66]
mem[128 len 8] = Mask(8, -(('mask_shl', 8, 248, -3, "'0'"), 0) + 256, 0) << (('mask_shl', 8, 248, -3, "'0'"), 0) - 256
mem[129 len 8] = Mask(8, -(('mask_shl', 8, 248, -3, "'x'"), 0) + 256, 0) << (('mask_shl', 8, 248, -3, "'x'"), 0) - 256
idx = 65
s = _tokenId
while idx > 1:
if s % 16 >= 16:
revert with 'NH{q', 50
if idx >= 66:
revert with 'NH{q', 50
mem[idx + 128 len 8] = Mask(8, -(0, 0) + 256, 0) << (0, 0) - 256
if not idx:
revert with 'NH{q', 17
idx = idx - 1
s = Mask(252, 0, s) * 0.0625
continue
if _tokenId + 16384:
revert with 0, 'Strings: hex length insufficient'
if not bool(stor9.length):
if not bool(stor9.length) - (stor9.length.field_1 % 128 < 32):
revert with 'NH{q', 34
if not bool(stor9.length):
mem[256] = Mask(248, 8, stor9.length)
idx = 0
while idx < 66:
mem[idx + (stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + 256] = mem[idx + 128]
idx = idx + 32
continue
mem[(stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + 322] = 0
if bool(stor10.length):
if not bool(stor10.length) - (uint255(stor10.length) * 0.5 < 32):
revert with 'NH{q', 34
if not bool(stor10.length):
mem[(stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + 322] = Mask(248, 8, stor10.length)
_508 = mem[64]
mem[64] = (stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 322
mem[(stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 322] = 32
_576 = mem[_508]
mem[(stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 354] = mem[_508]
idx = 0
while idx < _576:
mem[idx + (stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 386] = mem[idx + _508 + 32]
idx = idx + 32
continue
if ceil32(_576) > _576:
mem[_576 + (stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 386] = 0
return memory
from mem[64]
len ceil32(_576) + (stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + -mem[64] + 386
if bool(stor10.length) != 1:
_527 = mem[64]
mem[64] = 0
mem[0] = 32
_610 = mem[_527]
mem[32] = mem[_527]
mem[64 len ceil32(_610)] = mem[_527 + 32 len ceil32(_610)]
var61001 = ceil32(_610)
if ceil32(_610) > _610:
mem[_610 + 64] = 0
return memory
from mem[64]
len ceil32(_610) + -mem[64] + 64
mem[0] = 10
idx = 0
s = 0
while idx < uint255(stor10.length) * 0.5:
mem[idx + (stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + 322] = stor[s + sha3(mem[0])]
idx = idx + 32
s = s + 1
continue
_987 = mem[64]
mem[64] = (stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + (uint255(stor10.length) * 0.5) + 322
mem[(stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + (uint255(stor10.length) * 0.5) + 322] = 32
_1083 = mem[_987]
mem[(stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + (uint255(stor10.length) * 0.5) + 354] = mem[_987]
idx = 0
while idx < _1083:
mem[idx + (stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + (uint255(stor10.length) * 0.5) + 386] = mem[idx + _987 + 32]
idx = idx + 32
continue
if ceil32(_1083) > _1083:
mem[_1083 + (stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + (uint255(stor10.length) * 0.5) + 386] = 0
return memory
from mem[64]
len ceil32(_1083) + (stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + (uint255(stor10.length) * 0.5) + -mem[64] + 386
if not bool(stor10.length) - (stor10.length.field_1 % 128 < 32):
revert with 'NH{q', 34
if not bool(stor10.length):
mem[(stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + 322] = Mask(248, 8, stor10.length)
_528 = mem[64]
mem[64] = (stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 322
mem[(stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 322] = 32
_611 = mem[_528]
mem[(stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 354] = mem[_528]
idx = 0
while idx < _611:
mem[idx + (stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 386] = mem[idx + _528 + 32]
idx = idx + 32
continue
if ceil32(_611) > _611:
mem[_611 + (stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 386] = 0
return memory
from mem[64]
len ceil32(_611) + (stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + -mem[64] + 386
if bool(stor10.length) != 1:
_552 = mem[64]
mem[64] = 0
mem[0] = 32
_636 = mem[_552]
mem[32] = mem[_552]
mem[64 len ceil32(_636)] = mem[_552 + 32 len ceil32(_636)]
var62001 = ceil32(_636)
if ceil32(_636) > _636:
mem[_636 + 64] = 0
return memory
from mem[64]
len ceil32(_636) + -mem[64] + 64
mem[0] = 10
idx = 0
s = 0
while idx < stor10.length.field_1 % 128:
mem[idx + (stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + 322] = stor[s + sha3(mem[0])]
idx = idx + 32
s = s + 1
continue
_988 = mem[64]
mem[64] = (stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + stor10.length.field_1 % 128 + 322
mem[(stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + stor10.length.field_1 % 128 + 322] = 32
_1084 = mem[_988]
mem[(stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + stor10.length.field_1 % 128 + 354] = mem[_988]
idx = 0
while idx < _1084:
mem[idx + (stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + stor10.length.field_1 % 128 + 386] = mem[idx + _988 + 32]
idx = idx + 32
continue
if ceil32(_1084) > _1084:
mem[_1084 + (stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + stor10.length.field_1 % 128 + 386] = 0
return memory
from mem[64]
len ceil32(_1084) + (stor9.length.field_1 % 128 * bool(stor9.length.field_1 % 128)) + stor10.length.field_1 % 128 + -mem[64] + 386
if bool(stor9.length) == 1:
idx = 0
s = 0
while idx < stor9.length.field_1 % 128:
mem[idx + 256] = stor9[s].field_0
idx = idx + 32
s = s + 1
continue
mem[stor9.length.field_1 % 128 + 256 len 96] = 0, mem[129 len 95]
mem[stor9.length.field_1 % 128 + 322] = 0
if bool(stor10.length):
if not bool(stor10.length) - (uint255(stor10.length) * 0.5 < 32):
revert with 'NH{q', 34
if bool(stor10.length):
if bool(stor10.length) == 1:
idx = 0
s = 0
while idx < uint255(stor10.length) * 0.5:
mem[idx + stor9.length.field_1 % 128 + 322] = stor10[s].field_0
idx = idx + 32
s = s + 1
continue
mem[stor9.length.field_1 % 128 + (uint255(stor10.length) * 0.5) + 322] = 32
mem[stor9.length.field_1 % 128 + (uint255(stor10.length) * 0.5) + 354] = mem[224]
mem[stor9.length.field_1 % 128 + (uint255(stor10.length) * 0.5) + 386 len ceil32(mem[224])] = mem[256 len ceil32(mem[224])]
if ceil32(mem[224]) > mem[224]:
mem[mem[224] + stor9.length.field_1 % 128 + (uint255(stor10.length) * 0.5) + 386] = 0
return Array(len=mem[224], data=mem[stor9.length.field_1 % 128 + (uint255(stor10.length) * 0.5) + 386 len ceil32(mem[224])])
mem[64] = 0
_1198 = mem[224]
mem[64 len ceil32(mem[224])] = mem[256 len ceil32(mem[224])]
var65001 = ceil32(_1198)
if ceil32(_1198) > _1198:
mem[_1198 + 64] = 0
return memory
from mem[64]
len ceil32(_1198) + -mem[64] + 64
mem[stor9.length.field_1 % 128 + 322] = Mask(248, 8, stor10.length)
mem[64] = stor9.length.field_1 % 128 + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 322
mem[stor9.length.field_1 % 128 + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 322] = 32
_1182 = mem[224]
mem[stor9.length.field_1 % 128 + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 354] = mem[224]
idx = 0
while idx < _1182:
mem[idx + stor9.length.field_1 % 128 + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 386] = mem[idx + 256]
idx = idx + 32
continue
if ceil32(_1182) > _1182:
mem[_1182 + stor9.length.field_1 % 128 + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 386] = 0
return memory
from mem[64]
len ceil32(_1182) + stor9.length.field_1 % 128 + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + -mem[64] + 386
if not bool(stor10.length) - (stor10.length.field_1 % 128 < 32):
revert with 'NH{q', 34
if bool(stor10.length):
if bool(stor10.length) != 1:
mem[64] = 0
_1208 = mem[224]
mem[64 len ceil32(mem[224])] = mem[256 len ceil32(mem[224])]
if ceil32(_1208) > _1208:
mem[_1208 + 64] = 0
return memory
from mem[64]
len ceil32(_1208) + -mem[64] + 64
idx = 0
s = 0
while idx < stor10.length.field_1 % 128:
mem[idx + stor9.length.field_1 % 128 + 322] = stor10[s].field_0
idx = idx + 32
s = s + 1
continue
mem[stor9.length.field_1 % 128 + stor10.length.field_1 % 128 + 322] = 32
mem[stor9.length.field_1 % 128 + stor10.length.field_1 % 128 + 354] = mem[224]
mem[stor9.length.field_1 % 128 + stor10.length.field_1 % 128 + 386 len ceil32(mem[224])] = mem[256 len ceil32(mem[224])]
if ceil32(mem[224]) > mem[224]:
mem[mem[224] + stor9.length.field_1 % 128 + stor10.length.field_1 % 128 + 386] = 0
return Array(len=mem[224], data=mem[stor9.length.field_1 % 128 + stor10.length.field_1 % 128 + 386 len ceil32(mem[224])])
mem[stor9.length.field_1 % 128 + 322] = Mask(248, 8, stor10.length)
mem[64] = stor9.length.field_1 % 128 + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 322
mem[stor9.length.field_1 % 128 + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 322] = 32
_1199 = mem[224]
mem[stor9.length.field_1 % 128 + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 354] = mem[224]
idx = 0
while idx < _1199:
mem[idx + stor9.length.field_1 % 128 + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 386] = mem[idx + 256]
idx = idx + 32
continue
if ceil32(_1199) > _1199:
mem[_1199 + stor9.length.field_1 % 128 + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 386] = 0
return memory
from mem[64]
len ceil32(_1199) + stor9.length.field_1 % 128 + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + -mem[64] + 386
mem[0 len 96] = 0, mem[129 len 95]
mem[66] = 0
if not bool(stor10.length):
if not bool(stor10.length) - (stor10.length.field_1 % 128 < 32):
revert with 'NH{q', 34
if not bool(stor10.length):
mem[66] = Mask(248, 8, stor10.length)
_534 = mem[256 len 2], Mask(240, 0, stor10.length.field_16)
mem[64] = (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 66
mem[(stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 66] = 32
_621 = mem[_534]
mem[(stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 98] = mem[_534]
idx = 0
while idx < _621:
mem[idx + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 130] = mem[idx + _534 + 32]
idx = idx + 32
continue
if ceil32(_621) > _621:
mem[_621 + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 130] = 0
return memory
from mem[64]
len ceil32(_621) + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + -mem[64] + 130
if bool(stor10.length) != 1:
mem[64] = 0
mem[0] = 32
_642 = mem[mem[256 len 2], 0]
mem[32] = mem[mem[256 len 2], 0]
mem[64 len ceil32(_642)] = mem[mem[256 len 2], 0 + 32 len ceil32(_642)]
var63001 = ceil32(_642)
if ceil32(_642) > _642:
mem[_642 + 64] = 0
return memory
from mem[64]
len ceil32(_642) + -mem[64] + 64
mem[0] = 10
idx = 0
s = 0
while idx < stor10.length.field_1 % 128:
mem[idx + 66] = stor10[s].field_0
idx = idx + 32
s = s + 1
continue
_992 = mem[64]
mem[64] = stor10.length.field_1 % 128 + 66
mem[stor10.length.field_1 % 128 + 66] = 32
_1088 = mem[_992]
mem[stor10.length.field_1 % 128 + 98] = mem[_992]
mem[stor10.length.field_1 % 128 + 130 len ceil32(_1088)] = mem[_992 + 32 len ceil32(_1088)]
if ceil32(_1088) > _1088:
mem[_1088 + stor10.length.field_1 % 128 + 130] = 0
return 32, mem[stor10.length.field_1 % 128 + 98 len ceil32(_1088) + 32]
if not bool(stor10.length) - (uint255(stor10.length) * 0.5 < 32):
revert with 'NH{q', 34
if not bool(stor10.length):
mem[66] = Mask(248, 8, stor10.length)
_510 = mem[256 len 2], Mask(240, 0, stor10.length.field_16)
mem[64] = (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 66
mem[(uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 66] = 32
_584 = mem[_510]
mem[(uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 98] = mem[_510]
idx = 0
while idx < _584:
mem[idx + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 130] = mem[idx + _510 + 32]
idx = idx + 32
continue
if ceil32(_584) > _584:
mem[_584 + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 130] = 0
return memory
from mem[64]
len ceil32(_584) + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + -mem[64] + 130
if bool(stor10.length) != 1:
mem[64] = 0
mem[0] = 32
_620 = mem[mem[256 len 2], 0]
mem[32] = mem[mem[256 len 2], 0]
mem[64 len ceil32(_620)] = mem[mem[256 len 2], 0 + 32 len ceil32(_620)]
var62001 = ceil32(_620)
if ceil32(_620) > _620:
mem[_620 + 64] = 0
return memory
from mem[64]
len ceil32(_620) + -mem[64] + 64
mem[0] = 10
idx = 0
s = 0
while idx < uint255(stor10.length) * 0.5:
mem[idx + 66] = stor10[s].field_0
idx = idx + 32
s = s + 1
continue
_991 = mem[64]
mem[64] = (uint255(stor10.length) * 0.5) + 66
mem[(uint255(stor10.length) * 0.5) + 66] = 32
_1087 = mem[_991]
mem[(uint255(stor10.length) * 0.5) + 98] = mem[_991]
mem[(uint255(stor10.length) * 0.5) + 130 len ceil32(_1087)] = mem[_991 + 32 len ceil32(_1087)]
var65001 = ceil32(_1087)
if ceil32(_1087) > _1087:
mem[_1087 + (uint255(stor10.length) * 0.5) + 130] = 0
return 32, mem[(uint255(stor10.length) * 0.5) + 98 len ceil32(_1087) + 32]
if not bool(stor9.length) - (uint255(stor9.length) * 0.5 < 32):
revert with 'NH{q', 34
if not bool(stor9.length):
mem[256] = Mask(248, 8, stor9.length)
idx = 0
while idx < 66:
mem[idx + (uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + 256] = mem[idx + 128]
idx = idx + 32
continue
mem[(uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + 322] = 0
if bool(stor10.length):
if not bool(stor10.length) - (uint255(stor10.length) * 0.5 < 32):
revert with 'NH{q', 34
if not bool(stor10.length):
mem[(uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + 322] = Mask(248, 8, stor10.length)
_504 = mem[64]
mem[64] = (uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 322
mem[(uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 322] = 32
_562 = mem[_504]
mem[(uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 354] = mem[_504]
idx = 0
while idx < _562:
mem[idx + (uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 386] = mem[idx + _504 + 32]
idx = idx + 32
continue
if ceil32(_562) > _562:
mem[_562 + (uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 386] = 0
return memory
from mem[64]
len ceil32(_562) + (uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + -mem[64] + 386
if bool(stor10.length) != 1:
_515 = mem[64]
mem[64] = 0
mem[0] = 32
_592 = mem[_515]
mem[32] = mem[_515]
mem[64 len ceil32(_592)] = mem[_515 + 32 len ceil32(_592)]
var60001 = ceil32(_592)
if ceil32(_592) > _592:
mem[_592 + 64] = 0
return memory
from mem[64]
len ceil32(_592) + -mem[64] + 64
mem[0] = 10
idx = 0
s = 0
while idx < uint255(stor10.length) * 0.5:
mem[idx + (uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + 322] = stor[s + sha3(mem[0])]
idx = idx + 32
s = s + 1
continue
_979 = mem[64]
mem[64] = (uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + (uint255(stor10.length) * 0.5) + 322
mem[(uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + (uint255(stor10.length) * 0.5) + 322] = 32
_1075 = mem[_979]
mem[(uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + (uint255(stor10.length) * 0.5) + 354] = mem[_979]
idx = 0
while idx < _1075:
mem[idx + (uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + (uint255(stor10.length) * 0.5) + 386] = mem[idx + _979 + 32]
idx = idx + 32
continue
if ceil32(_1075) > _1075:
mem[_1075 + (uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + (uint255(stor10.length) * 0.5) + 386] = 0
return memory
from mem[64]
len ceil32(_1075) + (uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + (uint255(stor10.length) * 0.5) + -mem[64] + 386
if not bool(stor10.length) - (stor10.length.field_1 % 128 < 32):
revert with 'NH{q', 34
if not bool(stor10.length):
mem[(uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + 322] = Mask(248, 8, stor10.length)
_516 = mem[64]
mem[64] = (uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 322
mem[(uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 322] = 32
_593 = mem[_516]
mem[(uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 354] = mem[_516]
idx = 0
while idx < _593:
mem[idx + (uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 386] = mem[idx + _516 + 32]
idx = idx + 32
continue
if ceil32(_593) > _593:
mem[_593 + (uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 386] = 0
return memory
from mem[64]
len ceil32(_593) + (uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + -mem[64] + 386
if bool(stor10.length) != 1:
_540 = mem[64]
mem[64] = 0
mem[0] = 32
_626 = mem[_540]
mem[32] = mem[_540]
mem[64 len ceil32(_626)] = mem[_540 + 32 len ceil32(_626)]
var61001 = ceil32(_626)
if ceil32(_626) > _626:
mem[_626 + 64] = 0
return memory
from mem[64]
len ceil32(_626) + -mem[64] + 64
mem[0] = 10
idx = 0
s = 0
while idx < stor10.length.field_1 % 128:
mem[idx + (uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + 322] = stor[s + sha3(mem[0])]
idx = idx + 32
s = s + 1
continue
_980 = mem[64]
mem[64] = (uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + stor10.length.field_1 % 128 + 322
mem[(uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + stor10.length.field_1 % 128 + 322] = 32
_1076 = mem[_980]
mem[(uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + stor10.length.field_1 % 128 + 354] = mem[_980]
idx = 0
while idx < _1076:
mem[idx + (uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + stor10.length.field_1 % 128 + 386] = mem[idx + _980 + 32]
idx = idx + 32
continue
if ceil32(_1076) > _1076:
mem[_1076 + (uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + stor10.length.field_1 % 128 + 386] = 0
return memory
from mem[64]
len ceil32(_1076) + (uint255(stor9.length) * 0.5 * bool(uint255(stor9.length) * 0.5)) + stor10.length.field_1 % 128 + -mem[64] + 386
if bool(stor9.length) == 1:
idx = 0
s = 0
while idx < uint255(stor9.length) * 0.5:
mem[idx + 256] = stor9[s].field_0
idx = idx + 32
s = s + 1
continue
mem[(uint255(stor9.length) * 0.5) + 256 len 96] = 0, mem[129 len 95]
mem[(uint255(stor9.length) * 0.5) + 322] = 0
if bool(stor10.length):
if not bool(stor10.length) - (uint255(stor10.length) * 0.5 < 32):
revert with 'NH{q', 34
if bool(stor10.length):
if bool(stor10.length) == 1:
idx = 0
s = 0
while idx < uint255(stor10.length) * 0.5:
mem[idx + (uint255(stor9.length) * 0.5) + 322] = stor10[s].field_0
idx = idx + 32
s = s + 1
continue
mem[(uint255(stor9.length) * 0.5) + (uint255(stor10.length) * 0.5) + 322] = 32
mem[(uint255(stor9.length) * 0.5) + (uint255(stor10.length) * 0.5) + 354] = mem[224]
mem[(uint255(stor9.length) * 0.5) + (uint255(stor10.length) * 0.5) + 386 len ceil32(mem[224])] = mem[256 len ceil32(mem[224])]
if ceil32(mem[224]) > mem[224]:
mem[mem[224] + (uint255(stor9.length) * 0.5) + (uint255(stor10.length) * 0.5) + 386] = 0
return Array(len=mem[224], data=mem[(uint255(stor9.length) * 0.5) + (uint255(stor10.length) * 0.5) + 386 len ceil32(mem[224])]),
mem[64] = 0
_1190 = mem[224]
mem[64 len ceil32(mem[224])] = mem[256 len ceil32(mem[224])]
var64001 = ceil32(_1190)
if ceil32(_1190) > _1190:
mem[_1190 + 64] = 0
return memory
from mem[64]
len ceil32(_1190) + -mem[64] + 64
mem[(uint255(stor9.length) * 0.5) + 322] = Mask(248, 8, stor10.length)
mem[64] = (uint255(stor9.length) * 0.5) + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 322
mem[(uint255(stor9.length) * 0.5) + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 322] = 32
_1176 = mem[224]
mem[(uint255(stor9.length) * 0.5) + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 354] = mem[224]
idx = 0
while idx < _1176:
mem[idx + (uint255(stor9.length) * 0.5) + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 386] = mem[idx + 256]
idx = idx + 32
continue
if ceil32(_1176) > _1176:
mem[_1176 + (uint255(stor9.length) * 0.5) + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 386] = 0
return memory
from mem[64]
len ceil32(_1176) + (uint255(stor9.length) * 0.5) + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + -mem[64] + 386
if not bool(stor10.length) - (stor10.length.field_1 % 128 < 32):
revert with 'NH{q', 34
if bool(stor10.length):
if bool(stor10.length) == 1:
idx = 0
s = 0
while idx < stor10.length.field_1 % 128:
mem[idx + (uint255(stor9.length) * 0.5) + 322] = stor10[s].field_0
idx = idx + 32
s = s + 1
continue
mem[(uint255(stor9.length) * 0.5) + stor10.length.field_1 % 128 + 322] = 32
mem[(uint255(stor9.length) * 0.5) + stor10.length.field_1 % 128 + 354] = mem[224]
mem[(uint255(stor9.length) * 0.5) + stor10.length.field_1 % 128 + 386 len ceil32(mem[224])] = mem[256 len ceil32(mem[224])]
if ceil32(mem[224]) > mem[224]:
mem[mem[224] + (uint255(stor9.length) * 0.5) + stor10.length.field_1 % 128 + 386] = 0
return Array(len=mem[224], data=mem[(uint255(stor9.length) * 0.5) + stor10.length.field_1 % 128 + 386 len ceil32(mem[224])])
mem[64] = 0
_1204 = mem[224]
mem[64 len ceil32(mem[224])] = mem[256 len ceil32(mem[224])]
var65001 = ceil32(_1204)
if ceil32(_1204) > _1204:
mem[_1204 + 64] = 0
return memory
from mem[64]
len ceil32(_1204) + -mem[64] + 64
mem[(uint255(stor9.length) * 0.5) + 322] = Mask(248, 8, stor10.length)
mem[64] = (uint255(stor9.length) * 0.5) + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 322
mem[(uint255(stor9.length) * 0.5) + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 322] = 32
_1191 = mem[224]
mem[(uint255(stor9.length) * 0.5) + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 354] = mem[224]
idx = 0
while idx < _1191:
mem[idx + (uint255(stor9.length) * 0.5) + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 386] = mem[idx + 256]
idx = idx + 32
continue
if ceil32(_1191) > _1191:
mem[_1191 + (uint255(stor9.length) * 0.5) + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 386] = 0
return memory
from mem[64]
len ceil32(_1191) + (uint255(stor9.length) * 0.5) + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + -mem[64] + 386
mem[0 len 96] = 0, mem[129 len 95]
var42001 = 96
mem[66] = 0
if bool(stor10.length):
if not bool(stor10.length) - (uint255(stor10.length) * 0.5 < 32):
revert with 'NH{q', 34
if not bool(stor10.length):
mem[66] = Mask(248, 8, stor10.length)
_506 = mem[256 len 2], Mask(240, 0, stor10.length.field_16)
mem[64] = (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 66
mem[(uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 66] = 32
_570 = mem[_506]
mem[(uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 98] = mem[_506]
idx = 0
while idx < _570:
mem[idx + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 130] = mem[idx + _506 + 32]
idx = idx + 32
continue
if ceil32(_570) > _570:
mem[_570 + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + 130] = 0
return memory
from mem[64]
len ceil32(_570) + (uint255(stor10.length) * 0.5 * bool(uint255(stor10.length) * 0.5)) + -mem[64] + 130
if bool(stor10.length) != 1:
mem[64] = 0
mem[0] = 32
_602 = mem[mem[256 len 2], 0]
mem[32] = mem[mem[256 len 2], 0]
mem[64 len ceil32(_602)] = mem[mem[256 len 2], 0 + 32 len ceil32(_602)]
var61001 = ceil32(_602)
if ceil32(_602) > _602:
mem[_602 + 64] = 0
return memory
from mem[64]
len ceil32(_602) + -mem[64] + 64
mem[0] = 10
idx = 0
s = 0
while idx < uint255(stor10.length) * 0.5:
mem[idx + 66] = stor10[s].field_0
idx = idx + 32
s = s + 1
continue
_983 = mem[64]
mem[64] = (uint255(stor10.length) * 0.5) + 66
mem[(uint255(stor10.length) * 0.5) + 66] = 32
_1079 = mem[_983]
mem[(uint255(stor10.length) * 0.5) + 98] = mem[_983]
mem[(uint255(stor10.length) * 0.5) + 130 len ceil32(_1079)] = mem[_983 + 32 len ceil32(_1079)]
var64001 = ceil32(_1079)
if ceil32(_1079) > _1079:
mem[_1079 + (uint255(stor10.length) * 0.5) + 130] = 0
return 32, mem[(uint255(stor10.length) * 0.5) + 98 len ceil32(_1079) + 32]
if not bool(stor10.length) - (stor10.length.field_1 % 128 < 32):
revert with 'NH{q', 34
if not bool(stor10.length):
mem[66] = Mask(248, 8, stor10.length)
_522 = mem[256 len 2], Mask(240, 0, stor10.length.field_16)
mem[64] = (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 66
mem[(stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 66] = 32
_603 = mem[_522]
mem[(stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 98] = mem[_522]
idx = 0
while idx < _603:
mem[idx + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 130] = mem[idx + _522 + 32]
idx = idx + 32
continue
if ceil32(_603) > _603:
mem[_603 + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + 130] = 0
return memory
from mem[64]
len ceil32(_603) + (stor10.length.field_1 % 128 * bool(stor10.length.field_1 % 128)) + -mem[64] + 130
if bool(stor10.length) != 1:
mem[64] = 0
mem[0] = 32
_632 = mem[mem[256 len 2], 0]
mem[32] = mem[mem[256 len 2], 0]
mem[64 len ceil32(_632)] = mem[mem[256 len 2], 0 + 32 len ceil32(_632)]
var62001 = ceil32(_632)
if ceil32(_632) > _632:
mem[_632 + 64] = 0
return memory
from mem[64]
len ceil32(_632) + -mem[64] + 64
mem[0] = 10
idx = 0
s = 0
while idx < stor10.length.field_1 % 128:
mem[idx + 66] = stor10[s].field_0
idx = idx + 32
s = s + 1
continue
_984 = mem[64]
mem[64] = stor10.length.field_1 % 128 + 66
mem[stor10.length.field_1 % 128 + 66] = 32
_1080 = mem[_984]
mem[stor10.length.field_1 % 128 + 98] = mem[_984]
mem[stor10.length.field_1 % 128 + 130 len ceil32(_1080)] = mem[_984 + 32 len ceil32(_1080)]
var65001 = ceil32(_1080)
if ceil32(_1080) > _1080:
mem[_1080 + stor10.length.field_1 % 128 + 130] = 0
return 32, mem[stor10.length.field_1 % 128 + 98 len ceil32(_1080) + 32]
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment