Analysis Run

{"no_findings":false,"summary":"One medium-risk issue: the allowlisted executor path can initiate external CALLs with computed targets and ETH value, so misconfiguration/compromise of the allowlist can drain contract-held assets.","findings":[{"severity":"medium","category":"access_control","title":"Allowlisted executor can perform arbitrary external CALLs with ETH value","exploit_scenario":"The selector at 0x069cb1d5 enforces a canCallAddress[msg.sender] allowlist, but once passed it executes multiple CALLs where target and value are computed from calldata. If the allowlist is misconfigured or a whitelisted key is compromised, the attacker can craft calldata to route tokens/ETH out of the contract (including ETH bribes via COINBASE) to arbitrary destinations, draining any balances held by the contract. Selector inference is best-effort from bytecode; the allowlist check is visible in the dispatcher/bytecode but higher-level intent is unknown.","recommendation":"Treat the allowlist as a critical control: limit it to trusted EOAs/contracts, use multisig/timelock for updates, and consider hard-allowlisting external targets (routers) or enforcing recipient/value caps. If the executor is intended to be general-purpose, document the trust model and keep contract balances minimal.","evidence":"analysis_artifact.callsites show CALL with computed target/value (returndata_checked unknown) at pc 0x262/0x3f6/0x4be/0x66e/0x754/0xa4a/0xb61/0xcf6/0xe2b; detector_findings flag untrusted CALL target/value reachable. The allowlist check for canCallAddress[msg.sender] appears in the 0x069cb1d5 path before executing these calls.","locations":["selector:0x069cb1d5","pc:0x262","pc:0x3f6","pc:0x4be","pc:0x66e","pc:0x754","pc:0xa4a","pc:0xb61","pc:0xcf6","pc:0xe2b"]}]}

OpenAI Codex v0.77.0 (research preview)
--------
workdir: /tmp/codex-se1rzs0g
model: gpt-5.2-codex
provider: openai
approval: never
sandbox: read-only
reasoning effort: high
reasoning summaries: auto
session id: 019baa53-bc25-7b11-a01b-a960c09ecc6a
--------
user
You are a security auditor. You ONLY have runtime bytecode + analysis artifacts.
You MUST read `BYTECODE_BUNDLE.json` before concluding; it contains the bytecode summary,
evidence bundle, callsites, storage slots, and detector findings.

Special cases when reasoning from bytecode (be explicit about uncertainty):
- Selector inference is best-effort; missing selectors are common.
- Fallback/receive paths may be the only entrypoints.
- CALL vs DELEGATECALL semantics differ; DELEGATECALL executes in caller storage.
- Proxy patterns (EIP-1967, minimal proxies, beacon) change which storage is authoritative.
- Storage slots are raw; mappings/arrays appear via keccak patterns, names are unknown.
- Guard detection is heuristic; absence of guards does NOT mean unguarded.
- Returndata checking is unknown unless explicitly shown in evidence.
- Precompiles (0x1..0x9) and common ERC20 transfer selectors may appear; do not over-claim.

Output MUST be valid JSON matching the provided schema.
- If you find nothing meaningful: set no_findings=true and findings=[].
- Otherwise: set no_findings=false and include findings with severity/category/title.
- Locations can be pc references like "pc:0x123" or selectors like "selector:0xa9059cbb".

Focus on: reentrancy, access control, upgradeability/proxy issues, signature validation,
accounting/invariant breaks, dangerous delegatecall, and untrusted external calls.
Be conservative: if evidence is weak, mark severity low/medium and explain why.
mcp startup: no servers

thinking
**Reading BYTECODE_BUNDLE.json**
exec
/bin/bash -lc ls in /tmp/codex-se1rzs0g succeeded in 6ms:
BYTECODE_BUNDLE.json
codex-output-schema.json
exec
/bin/bash -lc 'cat BYTECODE_BUNDLE.json' in /tmp/codex-se1rzs0g succeeded in 6ms:
{
  "analysis_artifact": {
    "address": "0xadd45159f83dada41bdd4b5c87fedafcccbdfbc6",
    "artifact_hash": "0x1687d4e926b2efc038e883476f461d276bfe93695e32c39ab398c700af85d110",
    "artifact_json": {
      "auth": {
        "guards": [
          {
            "pc": 493,
            "type": "msg_sender_eq_const",
            "value": "0xffffffffffffffffffffffffffffffffffffffff"
          },
          {
            "pc": 1105,
            "type": "msg_sender_eq_const",
            "value": "0xffffffffffffffffffffffffffffffffffffffff"
          },
          {
            "pc": 1296,
            "type": "msg_sender_eq_const",

thinking
**Searching for bytecode evidence**
exec
/bin/bash -lc 'rg -n "storage|slot|selector|evidence|proxy|delegatecall|CALL" BYTECODE_BUNDLE.json | head -n 200' in /tmp/codex-se1rzs0g succeeded in 7ms:
44:            "CALLDATASIZE",
56:            "CALLDATALOAD",
175:            "CALLDATASIZE",
205:            "CALLVALUE",
232:            "CALLDATASIZE",
269:            "CALLVALUE",
296:            "CALLDATASIZE",
354:            "CALLVALUE",
381:            "CALLDATASIZE",
418:            "CALLVALUE",
445:            "CALLDATASIZE",
482:            "CALLVALUE",
547:            "CALLVALUE",
574:            "CALLDATASIZE",
611:            "CALLVALUE",
638:            "CALLDATASIZE",
687:            "CALLER",
776:            "CALL",
855:            "CALLER",
1184:            "CALL",

thinking
**Searching relevant sections and planning JSON parsing**
exec
/bin/bash -lc "python - <<'PY'
import json, pprint
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
print(data.keys())
print('analysis_artifact keys',data['analysis_artifact'].keys())
print('detector_findings',len(data.get('detector_findings',[])))
print('heuristics_summary',data.get('heuristics_summary'))
PY" in /tmp/codex-se1rzs0g succeeded in 57ms:
dict_keys(['analysis_artifact', 'analysis_run', 'artifact', 'capability_graph', 'detector_findings', 'heuristics_summary'])
analysis_artifact keys dict_keys(['address', 'artifact_hash', 'artifact_json', 'block_number', 'chain_id', 'codehash', 'created_at', 'id', 'updated_at', 'version'])
detector_findings 2
heuristics_summary {'create2_count': 0, 'delegatecall_count': 0, 'flags': ['heavy_ext_balance_usage'], 'selfdestruct_count': 0}

thinking
**Inspecting capability_graph and artifact modules**
exec
/bin/bash -lc "python - <<'PY'
import json, pprint
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)

# list top-level keys under capability_graph maybe
cg=data.get('capability_graph')
print('capability_graph keys:', cg.keys())
# show selectors
print('selectors:', cg.get('selectors'))

# print function summaries if present
funcs=cg.get('functions',[])
print('functions count',len(funcs))
print('first function keys', funcs[0].keys())
print('first function', funcs[0])
PY" in /tmp/codex-se1rzs0g exited 1 in 41ms:
capability_graph keys: dict_keys(['address', 'block_number', 'chain_id', 'codehash', 'created_at', 'graph_hash', 'graph_json', 'id', 'updated_at', 'version'])
selectors: None
functions count 0
Traceback (most recent call last):
  File "<stdin>", line 14, in <module>
IndexError: list index out of range

thinking
**Inspecting capability_graph keys**
exec
/bin/bash -lc "python - <<'PY'
import json, pprint
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)

cj=data['capability_graph']['graph_json']
print(cj.keys())
print('dispatcher', cj.get('dispatcher_type'))
print('selectors', cj.get('selectors'))
# list functions entries maybe in 'functions'
for k in ['functions','nodes','edges','entrypoints']:
    if k in cj:
        print(k, type(cj[k]), 'len', len(cj[k]))
PY" in /tmp/codex-se1rzs0g succeeded in 40ms:
dict_keys(['edges', 'nodes', 'version'])
dispatcher None
selectors None
nodes <class 'list'> len 435
edges <class 'list'> len 380

thinking
**Analyzing graph node types**
exec
/bin/bash -lc "python - <<'PY'
import json
from collections import Counter
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)

nodes=data['capability_graph']['graph_json']['nodes']
ctr=Counter(n.get('type') for n in nodes)
print(ctr)
# show some function nodes
funcs=[n for n in nodes if n.get('type')=='function']
print('functions',len(funcs))
print(funcs)
# callsite nodes
calls=[n for n in nodes if n.get('type')=='callsite']
print('callsites',len(calls))
print(calls[:5])
# storage nodes maybe
storage=[n for n in nodes if n.get('type')=='storage']
print('storage nodes',len(storage))
print(storage[:2])
PY" in /tmp/codex-se1rzs0g succeeded in 27ms:
Counter({'basic_block': 416, 'callsite': 10, 'function': 7, 'sink': 2})
functions 7
[{'entry_pc': 1766451330, 'id': 'fn:0x6949e882', 'selector': '0x6949e882', 'type': 'function'}, {'entry_pc': 3065339685, 'id': 'fn:0x8da5cb5b', 'selector': '0x8da5cb5b', 'type': 'function'}, {'entry_pc': 3708545555, 'id': 'fn:0xb6b55f25', 'selector': '0xb6b55f25', 'type': 'function'}, {'entry_pc': None, 'id': 'fn:0xdd0bea13', 'selector': '0xdd0bea13', 'type': 'function'}, {'entry_pc': 110932437, 'id': 'fn:0x0368fb76', 'selector': '0x0368fb76', 'type': 'function'}, {'entry_pc': 1097230829, 'id': 'fn:0x069cb1d5', 'selector': '0x069cb1d5', 'type': 'function'}, {'entry_pc': None, 'id': 'fn:0x416669ed', 'selector': '0x416669ed', 'type': 'function'}]
callsites 10
[{'id': 'call:610', 'opcode': 'CALL', 'pc': 610, 'type': 'callsite'}, {'id': 'call:1014', 'opcode': 'CALL', 'pc': 1014, 'type': 'callsite'}, {'id': 'call:1214', 'opcode': 'CALL', 'pc': 1214, 'type': 'callsite'}, {'id': 'call:1646', 'opcode': 'CALL', 'pc': 1646, 'type': 'callsite'}, {'id': 'call:1876', 'opcode': 'CALL', 'pc': 1876, 'type': 'callsite'}]
storage nodes 0
[]

thinking
**Investigating storage keys in artifact JSON**
exec
/bin/bash -lc "python - <<'PY'
import json, pprint
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)

a=data['analysis_artifact']['artifact_json']
print(a.keys())
# look for storage-like keys
for k in a.keys():
    if 'storage' in k:
        print('storage key', k)

# there is 'functions' maybe? print keys around
for k,v in a.items():
    if isinstance(v, dict) and 'storage' in v:
        print('dict with storage', k)

# search in artifact_json for 'storage' recursively

def find_storage(obj, path=''):
    if isinstance(obj, dict):
        for k,v in obj.items():
            newp=f'{path}.{k}' if path else k
            if 'storage' in k:
                print('found key', newp)
            find_storage(v,newp)
    elif isinstance(obj, list):
        for i,v in enumerate(obj):
            find_storage(v,f'{path}[{i}]')

find_storage(a)
PY" in /tmp/codex-se1rzs0g succeeded in 66ms:
dict_keys(['auth', 'basic_blocks', 'callsites', 'cfg_edges', 'cfg_hash', 'dispatcher_type', 'function_entries', 'functions', 'selectors', 'sinks', 'storage', 'version'])
storage key storage
found key functions[0].storage
found key functions[1].storage
found key functions[2].storage
found key functions[3].storage
found key functions[4].storage
found key functions[5].storage
found key functions[6].storage
found key storage

thinking
**Inspecting functions in artifact_json**
exec
/bin/bash -lc "python - <<'PY'
import json, pprint
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)

funcs=data['analysis_artifact']['artifact_json']['functions']
print('func count', len(funcs))
for f in funcs:
    print('selector', f.get('selector'), 'entry_pc', f.get('entry_pc'))
    print('call_count', f.get('call_count'), 'delegatecall', f.get('delegatecall'))
    print('storage slots len', len(f.get('storage',{}).get('slots',[])))
    print('guards', f.get('guards'))
    print('---')
PY" in /tmp/codex-se1rzs0g succeeded in 43ms:
func count 7
selector 0x6949e882 entry_pc 1766451330
call_count None delegatecall None
storage slots len 14
guards None
---
selector 0x8da5cb5b entry_pc 3065339685
call_count None delegatecall None
storage slots len 14
guards None
---
selector 0xb6b55f25 entry_pc 3708545555
call_count None delegatecall None
storage slots len 14
guards None
---
selector 0xdd0bea13 entry_pc None
call_count None delegatecall None
storage slots len 14
guards None

thinking
**Inspecting function storage details**
exec
/bin/bash -lc "python - <<'PY'
import json, pprint
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)

f=data['analysis_artifact']['artifact_json']['functions'][0]
print(f.keys())
pprint.pp(f['storage'])
PY" in /tmp/codex-se1rzs0g succeeded in 57ms:
dict_keys(['auth', 'entry_pc', 'selector', 'sinks', 'storage'])
{'reads': 15,
 'slots': [{'op': 'SLOAD',
            'pc': 441,
            'slot': '0x0000000000000000000000000000000000000000000000000000000000000000'},
           {'op': 'SLOAD',
            'pc': 738,
            'slot': '0x0000000000000000000000000000000000000000000000000000000000000000'},
           {'op': 'SLOAD',
            'pc': 1053,
            'slot': '0x0000000000000000000000000000000000000000000000000000000000000000'},
           {'op': 'SLOAD',
            'pc': 1138,
            'slot': '0x0000000000000000000000000000000000000000000000000000000000000000'},
           {'op': 'SLOAD',
            'pc': 1244,
            'slot': '0x0000000000000000000000000000000000000000000000000000000000000000'},
           {'op': 'SLOAD',
            'pc': 1420,
            'slot': '0x0000000000000000000000000000000000000000000000000000000000000000'},

thinking
**Inspecting storage writes**
exec
/bin/bash -lc "python - <<'PY'
import json, pprint
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)

storage=data['analysis_artifact']['artifact_json']['storage']
print(storage.keys())
print('reads', storage.get('reads'), 'writes', storage.get('writes'))
# print write slots
print('write slots')
for s in storage.get('slots',[]):
    if s.get('op')=='SSTORE':
        print(s)
PY" in /tmp/codex-se1rzs0g succeeded in 61ms:
dict_keys(['keccak_count', 'reads', 'slots', 'writes'])
reads 15 writes 1
write slots

thinking
**Inspecting slot operations in code**
exec
/bin/bash -lc "python - <<'PY'
import json
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)

slots=data['analysis_artifact']['artifact_json']['storage']['slots']
ops=set(s.get('op') for s in slots)
print('ops', ops)
# count ops
from collections import Counter
print(Counter(s.get('op') for s in slots))
# print any slot with op not SLOAD
for s in slots:
    if s.get('op')"'!='"'SLOAD':
        print(s)
PY" in /tmp/codex-se1rzs0g succeeded in 65ms:
ops {'SLOAD'}
Counter({'SLOAD': 14})

thinking
**Examining callsites in artifact_json**
exec
/bin/bash -lc "python - <<'PY'
import json, pprint
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)

callsites=data['analysis_artifact']['artifact_json']['callsites']
print('callsites', len(callsites))
for c in callsites:
    pprint.pp(c)
PY" in /tmp/codex-se1rzs0g succeeded in 50ms:
callsites 10
{'opcode': 'CALL',
 'pc': 610,
 'returndata_checked': None,
 'target_expression_category': 'computed',
 'value_expression_category': 'computed'}
{'opcode': 'CALL',
 'pc': 1014,
 'returndata_checked': None,
 'target_expression_category': 'computed',
 'value_expression_category': 'computed'}
{'opcode': 'CALL',
 'pc': 1214,
 'returndata_checked': None,
 'target_expression_category': 'computed',
 'value_expression_category': 'computed'}
{'opcode': 'CALL',
 'pc': 1646,
 'returndata_checked': None,
 'target_expression_category': 'computed',

thinking
**Investigating potential reentrancy risks**
exec
/bin/bash -lc "python - <<'PY'
import json, pprint
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)

print('analysis_run keys', data['analysis_run'].keys())
# maybe includes evidence?
pprint.pp(data['analysis_run'])
PY" in /tmp/codex-se1rzs0g succeeded in 56ms:
analysis_run keys dict_keys(['address', 'block_number', 'chain_id', 'child_links', 'created_at', 'id', 'parent_links', 'status', 'updated_at'])
{'address': '0xadd45159f83dada41bdd4b5c87fedafcccbdfbc6',
 'block_number': None,
 'chain_id': 1,
 'child_links': [],
 'created_at': '2026-01-10T21:47:16.000000Z',
 'id': '019ba9e0-bde8-721d-81bf-cec45f1439c0',
 'parent_links': [],
 'status': 'running',
 'updated_at': '2026-01-10T23:11:08.000000Z'}

thinking
**Inspecting top-level artifact**
exec
/bin/bash -lc "python - <<'PY'
import json, pprint
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)

artifact=data.get('artifact')
print('artifact keys', artifact.keys())
# print summary of artifact
for k in artifact.keys():
    if k not in ['bytecode','bytecode_runtime']:
        print(k, type(artifact[k]))
print('bytecode_runtime len', len(artifact.get('bytecode_runtime','')))

PY" in /tmp/codex-se1rzs0g succeeded in 59ms:
artifact keys dict_keys(['codehash', 'compiler_json', 'implementation_address', 'is_proxy', 'runtime_bytecode', 'verified_source'])
codehash <class 'str'>
compiler_json <class 'dict'>
implementation_address <class 'NoneType'>
is_proxy <class 'bool'>
runtime_bytecode <class 'dict'>
verified_source <class 'bool'>
bytecode_runtime len 0

thinking
**Inspecting runtime_bytecode fields**
exec
/bin/bash -lc "python - <<'PY'
import json, pprint
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)

rb=data['artifact']['runtime_bytecode']
print(rb.keys())
# maybe includes bytecode length and summary? print some fields
for k,v in rb.items():
    if k "'!= '"'bytecode' and k "'!= '"'opcodes':
        print(k, v if isinstance(v,(int,str,bool)) else type(v))
print('bytecode length', len(rb.get('bytecode','')))
print('opcodes len', len(rb.get('opcodes',[])))
PY" in /tmp/codex-se1rzs0g succeeded in 41ms:
dict_keys(['full', 'head', 'length', 'tail', 'truncated'])
full 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
head <class 'NoneType'>
length 12748
tail <class 'NoneType'>
truncated False
bytecode length 0
opcodes len 0

thinking
**Analyzing runtime bytecode structure**
exec
/bin/bash -lc "python - <<'PY'
import json, pprint
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)

selectors=data['analysis_artifact']['artifact_json'].get('selectors')
print('selectors len', len(selectors))
print(selectors)
PY" in /tmp/codex-se1rzs0g succeeded in 48ms:
selectors len 7
['0x6949e882', '0x8da5cb5b', '0xb6b55f25', '0xdd0bea13', '0x0368fb76', '0x069cb1d5', '0x416669ed']

thinking
**Searching for evidence bundle**
exec
/bin/bash -lc "python - <<'PY'
import json
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)

# search for evidence keys recursively

def find_keys(obj, key, path=''):
    if isinstance(obj, dict):
        for k,v in obj.items():
            p=f'{path}.{k}' if path else k
            if k==key:
                print('found', p)
            find_keys(v,key,p)
    elif isinstance(obj, list):
        for i,v in enumerate(obj):
            find_keys(v,key,f'{path}[{i}]')

find_keys(data,'evidence_bundle')
find_keys(data,'evidence_json')
PY" in /tmp/codex-se1rzs0g succeeded in 35ms:
found detector_findings[0].evidence_json
found detector_findings[1].evidence_json

thinking
**Analyzing bytecode with callsite mapping**

I'm exploring the artifact's runtime bytecode and its basic blocks to pinpoint calls at specific program counters. Since the environment is read-only and no evidence bundles exist aside from detectors, I plan to parse the bytecode with Python to identify untrusted calls or ETH transfers by mapping PCs to the corresponding basic blocks and inspecting nearby instructions. This approach should help me extract meaningful patterns even without a full decompiler.
exec
/bin/bash -lc "python - <<'PY'
import json
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)

bbs=data['analysis_artifact']['artifact_json']['basic_blocks']
pcs=[610,1014,1214,1646,1876,2634,2913,3318,3473,3627]
for pc in pcs:
    block=None
    for bb in bbs:
        if bb['start_pc']<=pc<=bb['end_pc']:
            block=bb
            break
    print('pc',pc,'block',block['start_pc'],block['end_pc'])
    print('opcodes',block['opcodes'])
    print('---')
PY" in /tmp/codex-se1rzs0g succeeded in 28ms:
pc 610 block 607 617
opcodes ['JUMPDEST', 'POP', 'GAS', 'CALL', 'ISZERO', 'OP_80', 'ISZERO', 'PUSH2', 'JUMPI']
---
pc 1014 block 967 1026
opcodes ['COINBASE', 'PUSH20', 'AND', 'PUSH2', 'OP_83', 'OP_90', 'OP_81', 'ISZERO', 'MUL', 'OP_90', 'PUSH1', 'MLOAD', 'PUSH1', 'PUSH1', 'MLOAD', 'OP_80', 'OP_83', 'SUB', 'OP_81', 'OP_85', 'OP_88', 'OP_88', 'CALL', 'OP_93', 'POP', 'POP', 'POP', 'POP', 'ISZERO', 'OP_80', 'ISZERO', 'PUSH2', 'JUMPI']
---
pc 1214 block 1134 1226
opcodes ['JUMPDEST', 'PUSH1', 'OP_80', 'SLOAD', 'OP_90', 'PUSH2', 'EXP', 'OP_90', 'DIV', 'PUSH20', 'AND', 'PUSH20', 'AND', 'PUSH2', 'OP_82', 'OP_90', 'OP_81', 'ISZERO', 'MUL', 'OP_90', 'PUSH1', 'MLOAD', 'PUSH1', 'PUSH1', 'MLOAD', 'OP_80', 'OP_83', 'SUB', 'OP_81', 'OP_85', 'OP_88', 'OP_88', 'CALL', 'OP_93', 'POP', 'POP', 'POP', 'POP', 'ISZERO', 'OP_80', 'ISZERO', 'PUSH2', 'JUMPI']
---
pc 1646 block 1643 1653
opcodes ['JUMPDEST', 'POP', 'GAS', 'CALL', 'ISZERO', 'OP_80', 'ISZERO', 'PUSH2', 'JUMPI']
---
pc 1876 block 1873 1883
opcodes ['JUMPDEST', 'POP', 'GAS', 'CALL', 'ISZERO', 'OP_80', 'ISZERO', 'PUSH2', 'JUMPI']
---
pc 2634 block 2631 2641
opcodes ['JUMPDEST', 'POP', 'GAS', 'CALL', 'ISZERO', 'OP_80', 'ISZERO', 'PUSH2', 'JUMPI']
---
pc 2913 block 2910 2920
opcodes ['JUMPDEST', 'POP', 'GAS', 'CALL', 'ISZERO', 'OP_80', 'ISZERO', 'PUSH2', 'JUMPI']

thinking
**Investigating call targets and patterns**
exec
/bin/bash -lc "python - <<'PY'
import json
with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
print('is_proxy', data['artifact'].get('is_proxy'))
print('implementation_address', data['artifact'].get('implementation_address'))
PY" in /tmp/codex-se1rzs0g succeeded in 35ms:
is_proxy False
implementation_address None

thinking
**Analyzing bytecode for access control and external calls**

I'm examining bytecode to identify functions protected by owner checks and to flag any external calls that untrusted users might trigger, especially those that could transfer funds. There’s complexity around function selectors and dispatching, so I plan to write a Python EVM disassembler to map program counters to opcodes and dissect key function logic more clearly.
exec
/bin/bash -lc "python - <<'PY'
import json
from collections import defaultdict

# Minimal opcode table
opcodes = {i: f'OP_{i:02x}' for i in range(256)}
# fill names
names = {
0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',
0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',
0x20:'SHA3',
0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',
0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',
0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',
0x60:'PUSH1',0x61:'PUSH2',0x62:'PUSH3',0x63:'PUSH4',0x64:'PUSH5',0x65:'PUSH6',0x66:'PUSH7',0x67:'PUSH8',0x68:'PUSH9',0x69:'PUSH10',0x6a:'PUSH11',0x6b:'PUSH12',0x6c:'PUSH13',0x6d:'PUSH14',0x6e:'PUSH15',0x6f:'PUSH16',0x70:'PUSH17',0x71:'PUSH18',0x72:'PUSH19',0x73:'PUSH20',0x74:'PUSH21',0x75:'PUSH22',0x76:'PUSH23',0x77:'PUSH24',0x78:'PUSH25',0x79:'PUSH26',0x7a:'PUSH27',0x7b:'PUSH28',0x7c:'PUSH29',0x7d:'PUSH30',0x7e:'PUSH31',0x7f:'PUSH32',
0x80:'DUP1',0x81:'DUP2',0x82:'DUP3',0x83:'DUP4',0x84:'DUP5',0x85:'DUP6',0x86:'DUP7',0x87:'DUP8',0x88:'DUP9',0x89:'DUP10',0x8a:'DUP11',0x8b:'DUP12',0x8c:'DUP13',0x8d:'DUP14',0x8e:'DUP15',0x8f:'DUP16',
0x90:'SWAP1',0x91:'SWAP2',0x92:'SWAP3',0x93:'SWAP4',0x94:'SWAP5',0x95:'SWAP6',0x96:'SWAP7',0x97:'SWAP8',0x98:'SWAP9',0x99:'SWAP10',0x9a:'SWAP11',0x9b:'SWAP12',0x9c:'SWAP13',0x9d:'SWAP14',0x9e:'SWAP15',0x9f:'SWAP16',
0xa0:'LOG0',0xa1:'LOG1',0xa2:'LOG2',0xa3:'LOG3',0xa4:'LOG4',
0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'
}

for k,v in names.items():
    opcodes[k]=v

with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
code=data['artifact']['runtime_bytecode']['full']
if code.startswith('0x'): code=code[2:]

# disassemble
ops=[]
pc=0
i=0
b=bytes.fromhex(code)
while pc < len(b):
    op=b[pc]
    name=opcodes.get(op,f'OP_{op:02x}')
    if 0x60 <= op <= 0x7f:
        n=op-0x5f
        imm=b[pc+1:pc+1+n]
        ops.append((pc,name,imm.hex()))
        pc+=1+n
    else:
        ops.append((pc,name,None))
        pc+=1

# helper to print around pc

def show(pc, n=20):
    # find index
    idx=None
    for i,(p,_,_) in enumerate(ops):
        if p==pc:
            idx=i; break
        if p>pc:
            idx=i; break
    if idx is None: idx=len(ops)-1
    start=max(0, idx-n)
    end=min(len(ops), idx+n)
    for p,name,imm in ops[start:end]:
        if imm is None:
            print(f'{p:04x}: {name}')
        else:
            print(f'{p:04x}: {name} 0x{imm}')
    print('---')

# show around some function entries from dispatch table
for pc in [0x01b5,0x029d,0x0419,0x04d8,0x0588,0x05ac,0x0687]:
    print('Function at', hex(pc))
    show(pc, n=25)

# show around callsites
for pc in [610,1014,1214,1646,1876,2634,2913,3318,3473,3627]:
    print('Callsite', pc)
    show(pc, n=15)
PY" in /tmp/codex-se1rzs0g succeeded in 38ms:
Function at 0x1b5
0190: PUSH2 0x0198
0193: JUMPI
0194: PUSH1 0x00
0196: DUP1
0197: REVERT
0198: JUMPDEST
0199: POP
019a: PUSH2 0x01b3
019d: PUSH1 0x04
019f: DUP1
01a0: CALLDATASIZE
01a1: SUB
01a2: DUP2
01a3: ADD
01a4: SWAP1
01a5: PUSH2 0x01ae
01a8: SWAP2
01a9: SWAP1
01aa: PUSH2 0x134a

thinking
**Analyzing disassembly and function mappings**
exec
/bin/bash -lc "python - <<'PY'
import json
from collections import defaultdict

# simple disassemble
opnames={
0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',
0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',
0x20:'SHA3',
0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',
0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',
0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',
0x60:'PUSH1',0x61:'PUSH2',0x62:'PUSH3',0x63:'PUSH4',0x64:'PUSH5',0x65:'PUSH6',0x66:'PUSH7',0x67:'PUSH8',0x68:'PUSH9',0x69:'PUSH10',0x6a:'PUSH11',0x6b:'PUSH12',0x6c:'PUSH13',0x6d:'PUSH14',0x6e:'PUSH15',0x6f:'PUSH16',0x70:'PUSH17',0x71:'PUSH18',0x72:'PUSH19',0x73:'PUSH20',0x74:'PUSH21',0x75:'PUSH22',0x76:'PUSH23',0x77:'PUSH24',0x78:'PUSH25',0x79:'PUSH26',0x7a:'PUSH27',0x7b:'PUSH28',0x7c:'PUSH29',0x7d:'PUSH30',0x7e:'PUSH31',0x7f:'PUSH32',
0x80:'DUP1',0x81:'DUP2',0x82:'DUP3',0x83:'DUP4',0x84:'DUP5',0x85:'DUP6',0x86:'DUP7',0x87:'DUP8',0x88:'DUP9',0x89:'DUP10',0x8a:'DUP11',0x8b:'DUP12',0x8c:'DUP13',0x8d:'DUP14',0x8e:'DUP15',0x8f:'DUP16',
0x90:'SWAP1',0x91:'SWAP2',0x92:'SWAP3',0x93:'SWAP4',0x94:'SWAP5',0x95:'SWAP6',0x96:'SWAP7',0x97:'SWAP8',0x98:'SWAP9',0x99:'SWAP10',0x9a:'SWAP11',0x9b:'SWAP12',0x9c:'SWAP13',0x9d:'SWAP14',0x9e:'SWAP15',0x9f:'SWAP16',
0xa0:'LOG0',0xa1:'LOG1',0xa2:'LOG2',0xa3:'LOG3',0xa4:'LOG4',
0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'
}

with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
code=data['artifact']['runtime_bytecode']['full']
if code.startswith('0x'): code=code[2:]
bs=bytes.fromhex(code)

ops=[]
pc=0
while pc < len(bs):
    op=bs[pc]
    name=opnames.get(op,f'OP_{op:02x}')
    if 0x60 <= op <= 0x7f:
        n=op-0x5f
        imm=bs[pc+1:pc+1+n]
        ops.append((pc,name,imm.hex()))
        pc+=1+n
    else:
        ops.append((pc,name,None))
        pc+=1

# print range
start=0x05ac
end=0x0670
for p,name,imm in ops:
    if start <= p <= end:
        if imm is None:
            print(f'{p:04x}: {name}')
        else:
            print(f'{p:04x}: {name} 0x{imm}')
PY" in /tmp/codex-se1rzs0g succeeded in 39ms:
05ac: JUMPDEST
05ad: PUSH1 0x00
05af: DUP1
05b0: SLOAD
05b1: SWAP1
05b2: PUSH2 0x0100
05b5: EXP
05b6: SWAP1
05b7: DIV
05b8: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
05cd: AND
05ce: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
05e3: AND
05e4: CALLER
05e5: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
05fa: AND
05fb: EQ
05fc: PUSH2 0x0601
05ff: JUMPI
0600: INVALID

thinking
**Analyzing payable token deposit call**
exec
/bin/bash -lc "python - <<'PY'
import json
from collections import defaultdict
opnames={
0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',
0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',0x20:'SHA3',0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',
0x60:'PUSH1',0x61:'PUSH2',0x62:'PUSH3',0x63:'PUSH4',0x64:'PUSH5',0x65:'PUSH6',0x66:'PUSH7',0x67:'PUSH8',0x68:'PUSH9',0x69:'PUSH10',0x6a:'PUSH11',0x6b:'PUSH12',0x6c:'PUSH13',0x6d:'PUSH14',0x6e:'PUSH15',0x6f:'PUSH16',0x70:'PUSH17',0x71:'PUSH18',0x72:'PUSH19',0x73:'PUSH20',0x74:'PUSH21',0x75:'PUSH22',0x76:'PUSH23',0x77:'PUSH24',0x78:'PUSH25',0x79:'PUSH26',0x7a:'PUSH27',0x7b:'PUSH28',0x7c:'PUSH29',0x7d:'PUSH30',0x7e:'PUSH31',0x7f:'PUSH32',
0x80:'DUP1',0x81:'DUP2',0x82:'DUP3',0x83:'DUP4',0x84:'DUP5',0x85:'DUP6',0x86:'DUP7',0x87:'DUP8',0x88:'DUP9',0x89:'DUP10',0x8a:'DUP11',0x8b:'DUP12',0x8c:'DUP13',0x8d:'DUP14',0x8e:'DUP15',0x8f:'DUP16',
0x90:'SWAP1',0x91:'SWAP2',0x92:'SWAP3',0x93:'SWAP4',0x94:'SWAP5',0x95:'SWAP6',0x96:'SWAP7',0x97:'SWAP8',0x98:'SWAP9',0x99:'SWAP10',0x9a:'SWAP11',0x9b:'SWAP12',0x9c:'SWAP13',0x9d:'SWAP14',0x9e:'SWAP15',0x9f:'SWAP16',
0xa0:'LOG0',0xa1:'LOG1',0xa2:'LOG2',0xa3:'LOG3',0xa4:'LOG4',
0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'}

with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
code=data['artifact']['runtime_bytecode']['full']
if code.startswith('0x'): code=code[2:]
bs=bytes.fromhex(code)
ops=[]
pc=0
while pc < len(bs):
    op=bs[pc]
    name=opnames.get(op,f'OP_{op:02x}')
    if 0x60 <= op <= 0x7f:
        n=op-0x5f
        imm=bs[pc+1:pc+1+n]
        ops.append((pc,name,imm.hex()))
        pc+=1+n
    else:
        ops.append((pc,name,None))
        pc+=1

start=0x0588
end=0x0625
for p,name,imm in ops:
    if start <= p <= end:
        if imm is None:
            print(f'{p:04x}: {name}')
        else:
            print(f'{p:04x}: {name} 0x{imm}')
PY" in /tmp/codex-se1rzs0g succeeded in 34ms:
0588: JUMPDEST
0589: PUSH1 0x00
058b: DUP1
058c: SLOAD
058d: SWAP1
058e: PUSH2 0x0100
0591: EXP
0592: SWAP1
0593: DIV
0594: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
05a9: AND
05aa: DUP2
05ab: JUMP
05ac: JUMPDEST
05ad: PUSH1 0x00
05af: DUP1
05b0: SLOAD
05b1: SWAP1
05b2: PUSH2 0x0100
05b5: EXP

thinking
**Analyzing owner-only functions and storage usage**
exec
/bin/bash -lc "python - <<'PY'
import json
opnames={
0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',
0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',0x20:'SHA3',
0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',
0x60:'PUSH1',0x61:'PUSH2',0x62:'PUSH3',0x63:'PUSH4',0x64:'PUSH5',0x65:'PUSH6',0x66:'PUSH7',0x67:'PUSH8',0x68:'PUSH9',0x69:'PUSH10',0x6a:'PUSH11',0x6b:'PUSH12',0x6c:'PUSH13',0x6d:'PUSH14',0x6e:'PUSH15',0x6f:'PUSH16',0x70:'PUSH17',0x71:'PUSH18',0x72:'PUSH19',0x73:'PUSH20',0x74:'PUSH21',0x75:'PUSH22',0x76:'PUSH23',0x77:'PUSH24',0x78:'PUSH25',0x79:'PUSH26',0x7a:'PUSH27',0x7b:'PUSH28',0x7c:'PUSH29',0x7d:'PUSH30',0x7e:'PUSH31',0x7f:'PUSH32',
0x80:'DUP1',0x81:'DUP2',0x82:'DUP3',0x83:'DUP4',0x84:'DUP5',0x85:'DUP6',0x86:'DUP7',0x87:'DUP8',0x88:'DUP9',0x89:'DUP10',0x8a:'DUP11',0x8b:'DUP12',0x8c:'DUP13',0x8d:'DUP14',0x8e:'DUP15',0x8f:'DUP16',
0x90:'SWAP1',0x91:'SWAP2',0x92:'SWAP3',0x93:'SWAP4',0x94:'SWAP5',0x95:'SWAP6',0x96:'SWAP7',0x97:'SWAP8',0x98:'SWAP9',0x99:'SWAP10',0x9a:'SWAP11',0x9b:'SWAP12',0x9c:'SWAP13',0x9d:'SWAP14',0x9e:'SWAP15',0x9f:'SWAP16',
0xa0:'LOG0',0xa1:'LOG1',0xa2:'LOG2',0xa3:'LOG3',0xa4:'LOG4',
0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'}

with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
code=data['artifact']['runtime_bytecode']['full']
if code.startswith('0x'): code=code[2:]
bs=bytes.fromhex(code)
ops=[]
pc=0
while pc < len(bs):
    op=bs[pc]
    name=opnames.get(op,f'OP_{op:02x}')
    if 0x60 <= op <= 0x7f:
        n=op-0x5f
        imm=bs[pc+1:pc+1+n]
        ops.append((pc,name,imm.hex()))
        pc+=1+n
    else:
        ops.append((pc,name,None))
        pc+=1

start=0x0419
end=0x04f5
for p,name,imm in ops:
    if start <= p <= end:
        if imm is None:
            print(f'{p:04x}: {name}')
        else:
            print(f'{p:04x}: {name} 0x{imm}')
PY" in /tmp/codex-se1rzs0g succeeded in 45ms:
0419: JUMPDEST
041a: PUSH1 0x00
041c: DUP1
041d: SLOAD
041e: SWAP1
041f: PUSH2 0x0100
0422: EXP
0423: SWAP1
0424: DIV
0425: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
043a: AND
043b: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
0450: AND
0451: CALLER
0452: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
0467: AND
0468: EQ
0469: PUSH2 0x046e
046c: JUMPI
046d: INVALID

thinking
**Analyzing CALL parameters and addresses**
exec
/bin/bash -lc "python - <<'PY'
import json
opnames={
0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',
0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',0x20:'SHA3',
0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',
0x60:'PUSH1',0x61:'PUSH2',0x62:'PUSH3',0x63:'PUSH4',0x64:'PUSH5',0x65:'PUSH6',0x66:'PUSH7',0x67:'PUSH8',0x68:'PUSH9',0x69:'PUSH10',0x6a:'PUSH11',0x6b:'PUSH12',0x6c:'PUSH13',0x6d:'PUSH14',0x6e:'PUSH15',0x6f:'PUSH16',0x70:'PUSH17',0x71:'PUSH18',0x72:'PUSH19',0x73:'PUSH20',0x74:'PUSH21',0x75:'PUSH22',0x76:'PUSH23',0x77:'PUSH24',0x78:'PUSH25',0x79:'PUSH26',0x7a:'PUSH27',0x7b:'PUSH28',0x7c:'PUSH29',0x7d:'PUSH30',0x7e:'PUSH31',0x7f:'PUSH32',
0x80:'DUP1',0x81:'DUP2',0x82:'DUP3',0x83:'DUP4',0x84:'DUP5',0x85:'DUP6',0x86:'DUP7',0x87:'DUP8',0x88:'DUP9',0x89:'DUP10',0x8a:'DUP11',0x8b:'DUP12',0x8c:'DUP13',0x8d:'DUP14',0x8e:'DUP15',0x8f:'DUP16',
0x90:'SWAP1',0x91:'SWAP2',0x92:'SWAP3',0x93:'SWAP4',0x94:'SWAP5',0x95:'SWAP6',0x96:'SWAP7',0x97:'SWAP8',0x98:'SWAP9',0x99:'SWAP10',0x9a:'SWAP11',0x9b:'SWAP12',0x9c:'SWAP13',0x9d:'SWAP14',0x9e:'SWAP15',0x9f:'SWAP16',
0xa0:'LOG0',0xa1:'LOG1',0xa2:'LOG2',0xa3:'LOG3',0xa4:'LOG4',
0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'}

with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
code=data['artifact']['runtime_bytecode']['full']
if code.startswith('0x'): code=code[2:]
bs=bytes.fromhex(code)
ops=[]
pc=0
while pc < len(bs):
    op=bs[pc]
    name=opnames.get(op,f'OP_{op:02x}')
    if 0x60 <= op <= 0x7f:
        n=op-0x5f
        imm=bs[pc+1:pc+1+n]
        ops.append((pc,name,imm.hex()))
        pc+=1+n
    else:
        ops.append((pc,name,None))
        pc+=1

# show around 0x08fc
start=0x08ec
end=0x090a
for p,name,imm in ops:
    if start <= p <= end:
        if imm is None:
            print(f'{p:04x}: {name}')
        else:
            print(f'{p:04x}: {name} 0x{imm}')
PY" in /tmp/codex-se1rzs0g succeeded in 31ms:
08ec: AND
08ed: SWAP1
08ee: DUP2
08ef: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
0904: AND
0905: DUP2
0906: MSTORE
0907: POP
0908: POP
0909: DUP7
090a: DUP2

thinking
**Analyzing call patterns and access controls**
exec
/bin/bash -lc "python - <<'PY'
import json
opnames={
0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',
0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',0x20:'SHA3',
0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',
0x60:'PUSH1',0x61:'PUSH2',0x62:'PUSH3',0x63:'PUSH4',0x64:'PUSH5',0x65:'PUSH6',0x66:'PUSH7',0x67:'PUSH8',0x68:'PUSH9',0x69:'PUSH10',0x6a:'PUSH11',0x6b:'PUSH12',0x6c:'PUSH13',0x6d:'PUSH14',0x6e:'PUSH15',0x6f:'PUSH16',0x70:'PUSH17',0x71:'PUSH18',0x72:'PUSH19',0x73:'PUSH20',0x74:'PUSH21',0x75:'PUSH22',0x76:'PUSH23',0x77:'PUSH24',0x78:'PUSH25',0x79:'PUSH26',0x7a:'PUSH27',0x7b:'PUSH28',0x7c:'PUSH29',0x7d:'PUSH30',0x7e:'PUSH31',0x7f:'PUSH32',
0x80:'DUP1',0x81:'DUP2',0x82:'DUP3',0x83:'DUP4',0x84:'DUP5',0x85:'DUP6',0x86:'DUP7',0x87:'DUP8',0x88:'DUP9',0x89:'DUP10',0x8a:'DUP11',0x8b:'DUP12',0x8c:'DUP13',0x8d:'DUP14',0x8e:'DUP15',0x8f:'DUP16',
0x90:'SWAP1',0x91:'SWAP2',0x92:'SWAP3',0x93:'SWAP4',0x94:'SWAP5',0x95:'SWAP6',0x96:'SWAP7',0x97:'SWAP8',0x98:'SWAP9',0x99:'SWAP10',0x9a:'SWAP11',0x9b:'SWAP12',0x9c:'SWAP13',0x9d:'SWAP14',0x9e:'SWAP15',0x9f:'SWAP16',
0xa0:'LOG0',0xa1:'LOG1',0xa2:'LOG2',0xa3:'LOG3',0xa4:'LOG4',
0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'}

with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
code=data['artifact']['runtime_bytecode']['full']
if code.startswith('0x'): code=code[2:]
bs=bytes.fromhex(code)
ops=[]
pc=0
while pc < len(bs):
    op=bs[pc]
    name=opnames.get(op,f'OP_{op:02x}')
    if 0x60 <= op <= 0x7f:
        n=op-0x5f
        imm=bs[pc+1:pc+1+n]
        ops.append((pc,name,imm.hex()))
        pc+=1+n
    else:
        ops.append((pc,name,None))
        pc+=1

# print first 200 bytes
for p,name,imm in ops:
    if p>0x120: break
    if imm is None:
        print(f'{p:04x}: {name}')
    else:
        print(f'{p:04x}: {name} 0x{imm}')
PY" in /tmp/codex-se1rzs0g succeeded in 66ms:
0000: PUSH1 0x80
0002: PUSH1 0x40
0004: MSTORE
0005: PUSH1 0x04
0007: CALLDATASIZE
0008: LT
0009: PUSH2 0x0074
000c: JUMPI
000d: PUSH1 0x00
000f: CALLDATALOAD
0010: PUSH1 0xe0
0012: SHR
0013: DUP1
0014: PUSH4 0x6949e882
0019: GT
001a: PUSH2 0x004e
001d: JUMPI
001e: DUP1
001f: PUSH4 0x6949e882
0024: EQ

thinking
**Mapping function selectors to code entries**
exec
/bin/bash -lc "python - <<'PY'
import json
opnames={
0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',
0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',0x20:'SHA3',
0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',
0x60:'PUSH1',0x61:'PUSH2',0x62:'PUSH3',0x63:'PUSH4',0x64:'PUSH5',0x65:'PUSH6',0x66:'PUSH7',0x67:'PUSH8',0x68:'PUSH9',0x69:'PUSH10',0x6a:'PUSH11',0x6b:'PUSH12',0x6c:'PUSH13',0x6d:'PUSH14',0x6e:'PUSH15',0x6f:'PUSH16',0x70:'PUSH17',0x71:'PUSH18',0x72:'PUSH19',0x73:'PUSH20',0x74:'PUSH21',0x75:'PUSH22',0x76:'PUSH23',0x77:'PUSH24',0x78:'PUSH25',0x79:'PUSH26',0x7a:'PUSH27',0x7b:'PUSH28',0x7c:'PUSH29',0x7d:'PUSH30',0x7e:'PUSH31',0x7f:'PUSH32',
0x80:'DUP1',0x81:'DUP2',0x82:'DUP3',0x83:'DUP4',0x84:'DUP5',0x85:'DUP6',0x86:'DUP7',0x87:'DUP8',0x88:'DUP9',0x89:'DUP10',0x8a:'DUP11',0x8b:'DUP12',0x8c:'DUP13',0x8d:'DUP14',0x8e:'DUP15',0x8f:'DUP16',
0x90:'SWAP1',0x91:'SWAP2',0x92:'SWAP3',0x93:'SWAP4',0x94:'SWAP5',0x95:'SWAP6',0x96:'SWAP7',0x97:'SWAP8',0x98:'SWAP9',0x99:'SWAP10',0x9a:'SWAP11',0x9b:'SWAP12',0x9c:'SWAP13',0x9d:'SWAP14',0x9e:'SWAP15',0x9f:'SWAP16',
0xa0:'LOG0',0xa1:'LOG1',0xa2:'LOG2',0xa3:'LOG3',0xa4:'LOG4',
0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'}

with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
code=data['artifact']['runtime_bytecode']['full']
if code.startswith('0x'): code=code[2:]
bs=bytes.fromhex(code)
ops=[]
pc=0
while pc < len(bs):
    op=bs[pc]
    name=opnames.get(op,f'OP_{op:02x}')
    if 0x60 <= op <= 0x7f:
        n=op-0x5f
        imm=bs[pc+1:pc+1+n]
        ops.append((pc,name,imm.hex()))
        pc+=1+n
    else:
        ops.append((pc,name,None))
        pc+=1

start=0x010f
end=0x0195
for p,name,imm in ops:
    if start <= p <= end:
        if imm is None:
            print(f'{p:04x}: {name}')
        else:
            print(f'{p:04x}: {name} 0x{imm}')
PY" in /tmp/codex-se1rzs0g succeeded in 34ms:
010f: JUMPDEST
0110: CALLVALUE
0111: DUP1
0112: ISZERO
0113: PUSH2 0x011b
0116: JUMPI
0117: PUSH1 0x00
0119: DUP1
011a: REVERT
011b: JUMPDEST
011c: POP
011d: PUSH2 0x0136
0120: PUSH1 0x04
0122: DUP1
0123: CALLDATASIZE
0124: SUB
0125: DUP2
0126: ADD
0127: SWAP1
0128: PUSH2 0x0131

thinking
**Analyzing owner and allowlist functions for risks**
exec
/bin/bash -lc "python - <<'PY'
import json
opnames={
0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',
0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',0x20:'SHA3',
0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',
0x60:'PUSH1',0x61:'PUSH2',0x62:'PUSH3',0x63:'PUSH4',0x64:'PUSH5',0x65:'PUSH6',0x66:'PUSH7',0x67:'PUSH8',0x68:'PUSH9',0x69:'PUSH10',0x6a:'PUSH11',0x6b:'PUSH12',0x6c:'PUSH13',0x6d:'PUSH14',0x6e:'PUSH15',0x6f:'PUSH16',0x70:'PUSH17',0x71:'PUSH18',0x72:'PUSH19',0x73:'PUSH20',0x74:'PUSH21',0x75:'PUSH22',0x76:'PUSH23',0x77:'PUSH24',0x78:'PUSH25',0x79:'PUSH26',0x7a:'PUSH27',0x7b:'PUSH28',0x7c:'PUSH29',0x7d:'PUSH30',0x7e:'PUSH31',0x7f:'PUSH32',
0x80:'DUP1',0x81:'DUP2',0x82:'DUP3',0x83:'DUP4',0x84:'DUP5',0x85:'DUP6',0x86:'DUP7',0x87:'DUP8',0x88:'DUP9',0x89:'DUP10',0x8a:'DUP11',0x8b:'DUP12',0x8c:'DUP13',0x8d:'DUP14',0x8e:'DUP15',0x8f:'DUP16',
0x90:'SWAP1',0x91:'SWAP2',0x92:'SWAP3',0x93:'SWAP4',0x94:'SWAP5',0x95:'SWAP6',0x96:'SWAP7',0x97:'SWAP8',0x98:'SWAP9',0x99:'SWAP10',0x9a:'SWAP11',0x9b:'SWAP12',0x9c:'SWAP13',0x9d:'SWAP14',0x9e:'SWAP15',0x9f:'SWAP16',
0xa0:'LOG0',0xa1:'LOG1',0xa2:'LOG2',0xa3:'LOG3',0xa4:'LOG4',
0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'}

with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
code=data['artifact']['runtime_bytecode']['full']
if code.startswith('0x'): code=code[2:]
bs=bytes.fromhex(code)
ops=[]
pc=0
while pc < len(bs):
    op=bs[pc]
    name=opnames.get(op,f'OP_{op:02x}')
    if 0x60 <= op <= 0x7f:
        n=op-0x5f
        imm=bs[pc+1:pc+1+n]
        ops.append((pc,name,imm.hex()))
        pc+=1+n
    else:
        ops.append((pc,name,None))
        pc+=1

start=0x029d
end=0x0410
for p,name,imm in ops:
    if start <= p <= end:
        if imm is None:
            print(f'{p:04x}: {name}')
        else:
            print(f'{p:04x}: {name} 0x{imm}')
PY" in /tmp/codex-se1rzs0g succeeded in 88ms:
029d: JUMPDEST
029e: PUSH1 0x00
02a0: PUSH1 0x01
02a2: PUSH1 0x00
02a4: CALLER
02a5: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
02ba: AND
02bb: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
02d0: AND
02d1: DUP2
02d2: MSTORE
02d3: PUSH1 0x20
02d5: ADD
02d6: SWAP1
02d7: DUP2
02d8: MSTORE
02d9: PUSH1 0x20
02db: ADD
02dc: PUSH1 0x00
02de: SHA3

thinking
**Analyzing function calling miner address**
exec
/bin/bash -lc "python - <<'PY'
import json
opnames={
0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',
0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',0x20:'SHA3',
0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',
0x60:'PUSH1',0x61:'PUSH2',0x62:'PUSH3',0x63:'PUSH4',0x64:'PUSH5',0x65:'PUSH6',0x66:'PUSH7',0x67:'PUSH8',0x68:'PUSH9',0x69:'PUSH10',0x6a:'PUSH11',0x6b:'PUSH12',0x6c:'PUSH13',0x6d:'PUSH14',0x6e:'PUSH15',0x6f:'PUSH16',0x70:'PUSH17',0x71:'PUSH18',0x72:'PUSH19',0x73:'PUSH20',0x74:'PUSH21',0x75:'PUSH22',0x76:'PUSH23',0x77:'PUSH24',0x78:'PUSH25',0x79:'PUSH26',0x7a:'PUSH27',0x7b:'PUSH28',0x7c:'PUSH29',0x7d:'PUSH30',0x7e:'PUSH31',0x7f:'PUSH32',
0x80:'DUP1',0x81:'DUP2',0x82:'DUP3',0x83:'DUP4',0x84:'DUP5',0x85:'DUP6',0x86:'DUP7',0x87:'DUP8',0x88:'DUP9',0x89:'DUP10',0x8a:'DUP11',0x8b:'DUP12',0x8c:'DUP13',0x8d:'DUP14',0x8e:'DUP15',0x8f:'DUP16',
0x90:'SWAP1',0x91:'SWAP2',0x92:'SWAP3',0x93:'SWAP4',0x94:'SWAP5',0x95:'SWAP6',0x96:'SWAP7',0x97:'SWAP8',0x98:'SWAP9',0x99:'SWAP10',0x9a:'SWAP11',0x9b:'SWAP12',0x9c:'SWAP13',0x9d:'SWAP14',0x9e:'SWAP15',0x9f:'SWAP16',
0xa0:'LOG0',0xa1:'LOG1',0xa2:'LOG2',0xa3:'LOG3',0xa4:'LOG4',
0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'}

with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
code=data['artifact']['runtime_bytecode']['full']
if code.startswith('0x'): code=code[2:]
bs=bytes.fromhex(code)
ops=[]
pc=0
while pc < len(bs):
    op=bs[pc]
    name=opnames.get(op,f'OP_{op:02x}')
    if 0x60 <= op <= 0x7f:
        n=op-0x5f
        imm=bs[pc+1:pc+1+n]
        ops.append((pc,name,imm.hex()))
        pc+=1+n
    else:
        ops.append((pc,name,None))
        pc+=1

start=0x076c
end=0x0b00
for p,name,imm in ops:
    if start <= p <= end:
        if imm is None:
            print(f'{p:04x}: {name}')
        else:
            print(f'{p:04x}: {name} 0x{imm}')
PY" in /tmp/codex-se1rzs0g succeeded in 63ms:
076c: JUMPDEST
076d: PUSH1 0x00
076f: DUP8
0770: PUSH1 0x01
0772: EQ
0773: ISZERO
0774: PUSH2 0x086b
0777: JUMPI
0778: PUSH1 0x00
077a: PUSH1 0x02
077c: PUSH8 0xffffffffffffffff
0785: DUP2
0786: GT
0787: DUP1
0788: ISZERO
0789: PUSH2 0x0791
078c: JUMPI
078d: PUSH1 0x00
078f: DUP1
0790: REVERT

thinking
**Analyzing potential vulnerabilities and external calls**
exec
/bin/bash -lc "python - <<'PY'
import json
opnames={
0x00:'STOP',0x01:'ADD',0x02:'MUL',0x03:'SUB',0x04:'DIV',0x05:'SDIV',0x06:'MOD',0x07:'SMOD',0x08:'ADDMOD',0x09:'MULMOD',0x0a:'EXP',0x0b:'SIGNEXTEND',
0x10:'LT',0x11:'GT',0x12:'SLT',0x13:'SGT',0x14:'EQ',0x15:'ISZERO',0x16:'AND',0x17:'OR',0x18:'XOR',0x19:'NOT',0x1a:'BYTE',0x1b:'SHL',0x1c:'SHR',0x1d:'SAR',0x20:'SHA3',
0x30:'ADDRESS',0x31:'BALANCE',0x32:'ORIGIN',0x33:'CALLER',0x34:'CALLVALUE',0x35:'CALLDATALOAD',0x36:'CALLDATASIZE',0x37:'CALLDATACOPY',0x38:'CODESIZE',0x39:'CODECOPY',0x3a:'GASPRICE',0x3b:'EXTCODESIZE',0x3c:'EXTCODECOPY',0x3d:'RETURNDATASIZE',0x3e:'RETURNDATACOPY',0x3f:'EXTCODEHASH',0x40:'BLOCKHASH',0x41:'COINBASE',0x42:'TIMESTAMP',0x43:'NUMBER',0x44:'DIFFICULTY',0x45:'GASLIMIT',0x46:'CHAINID',0x47:'SELFBALANCE',0x48:'BASEFEE',0x50:'POP',0x51:'MLOAD',0x52:'MSTORE',0x53:'MSTORE8',0x54:'SLOAD',0x55:'SSTORE',0x56:'JUMP',0x57:'JUMPI',0x58:'PC',0x59:'MSIZE',0x5a:'GAS',0x5b:'JUMPDEST',
0x60:'PUSH1',0x61:'PUSH2',0x62:'PUSH3',0x63:'PUSH4',0x64:'PUSH5',0x65:'PUSH6',0x66:'PUSH7',0x67:'PUSH8',0x68:'PUSH9',0x69:'PUSH10',0x6a:'PUSH11',0x6b:'PUSH12',0x6c:'PUSH13',0x6d:'PUSH14',0x6e:'PUSH15',0x6f:'PUSH16',0x70:'PUSH17',0x71:'PUSH18',0x72:'PUSH19',0x73:'PUSH20',0x74:'PUSH21',0x75:'PUSH22',0x76:'PUSH23',0x77:'PUSH24',0x78:'PUSH25',0x79:'PUSH26',0x7a:'PUSH27',0x7b:'PUSH28',0x7c:'PUSH29',0x7d:'PUSH30',0x7e:'PUSH31',0x7f:'PUSH32',
0x80:'DUP1',0x81:'DUP2',0x82:'DUP3',0x83:'DUP4',0x84:'DUP5',0x85:'DUP6',0x86:'DUP7',0x87:'DUP8',0x88:'DUP9',0x89:'DUP10',0x8a:'DUP11',0x8b:'DUP12',0x8c:'DUP13',0x8d:'DUP14',0x8e:'DUP15',0x8f:'DUP16',
0x90:'SWAP1',0x91:'SWAP2',0x92:'SWAP3',0x93:'SWAP4',0x94:'SWAP5',0x95:'SWAP6',0x96:'SWAP7',0x97:'SWAP8',0x98:'SWAP9',0x99:'SWAP10',0x9a:'SWAP11',0x9b:'SWAP12',0x9c:'SWAP13',0x9d:'SWAP14',0x9e:'SWAP15',0x9f:'SWAP16',
0xa0:'LOG0',0xa1:'LOG1',0xa2:'LOG2',0xa3:'LOG3',0xa4:'LOG4',
0xf0:'CREATE',0xf1:'CALL',0xf2:'CALLCODE',0xf3:'RETURN',0xf4:'DELEGATECALL',0xf5:'CREATE2',0xfa:'STATICCALL',0xfd:'REVERT',0xfe:'INVALID',0xff:'SELFDESTRUCT'}

with open('BYTECODE_BUNDLE.json') as f:
    data=json.load(f)
code=data['artifact']['runtime_bytecode']['full']
if code.startswith('0x'): code=code[2:]
bs=bytes.fromhex(code)
ops=[]
pc=0
while pc < len(bs):
    op=bs[pc]
    name=opnames.get(op,f'OP_{op:02x}')
    if 0x60 <= op <= 0x7f:
        n=op-0x5f
        imm=bs[pc+1:pc+1+n]
        ops.append((pc,name,imm.hex()))
        pc+=1+n
    else:
        ops.append((pc,name,None))
        pc+=1

start=0x0d3a
end=0x0e80
for p,name,imm in ops:
    if start <= p <= end:
        if imm is None:
            print(f'{p:04x}: {name}')
        else:
            print(f'{p:04x}: {name} 0x{imm}')
PY" in /tmp/codex-se1rzs0g succeeded in 46ms:
0d3a: JUMPDEST
0d3b: DUP1
0d3c: DUP4
0d3d: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
0d52: AND
0d53: PUSH4 0xdd62ed3e
0d58: ADDRESS
0d59: DUP6
0d5a: PUSH1 0x40
0d5c: MLOAD
0d5d: DUP4
0d5e: PUSH4 0xffffffff
0d63: AND
0d64: PUSH1 0xe0
0d66: SHL
0d67: DUP2
0d68: MSTORE
0d69: PUSH1 0x04
0d6b: ADD
0d6c: PUSH2 0x0d76

thinking
**Summarizing security analysis findings**

I’m preparing a JSON report with one medium-severity finding about the allowlisted executor enabling arbitrary external calls with ETH value, supported by specific callsite evidence and function selector. I’ll also note uncertainties around return-data checks and recommend tightening allowlists and access controls to mitigate potential fund drains.
codex
{"no_findings":false,"summary":"One medium-risk issue: the allowlisted executor path can initiate external CALLs with computed targets and ETH value, so misconfiguration/compromise of the allowlist can drain contract-held assets.","findings":[{"severity":"medium","category":"access_control","title":"Allowlisted executor can perform arbitrary external CALLs with ETH value","exploit_scenario":"The selector at 0x069cb1d5 enforces a canCallAddress[msg.sender] allowlist, but once passed it executes multiple CALLs where target and value are computed from calldata. If the allowlist is misconfigured or a whitelisted key is compromised, the attacker can craft calldata to route tokens/ETH out of the contract (including ETH bribes via COINBASE) to arbitrary destinations, draining any balances held by the contract. Selector inference is best-effort from bytecode; the allowlist check is visible in the dispatcher/bytecode but higher-level intent is unknown.","recommendation":"Treat the allowlist as a critical control: limit it to trusted EOAs/contracts, use multisig/timelock for updates, and consider hard-allowlisting external targets (routers) or enforcing recipient/value caps. If the executor is intended to be general-purpose, document the trust model and keep contract balances minimal.","evidence":"analysis_artifact.callsites show CALL with computed target/value (returndata_checked unknown) at pc 0x262/0x3f6/0x4be/0x66e/0x754/0xa4a/0xb61/0xcf6/0xe2b; detector_findings flag untrusted CALL target/value reachable. The allowlist check for canCallAddress[msg.sender] appears in the 0x069cb1d5 path before executing these calls.","locations":["selector:0x069cb1d5","pc:0x262","pc:0x3f6","pc:0x4be","pc:0x66e","pc:0x754","pc:0xa4a","pc:0xb61","pc:0xcf6","pc:0xe2b"]}]}
tokens used
115,642

{
    "codex": {
        "ran_at": "2026-01-11T00:02:34.797545+00:00",
        "returncode": 0
    },
    "project": {
        "mode": "bytecode",
        "bytecode_length": 12748,
        "bytecode_truncated": false,
        "capability_graph_present": true,
        "analysis_artifact_present": true
    },
    "summary": "One medium-risk issue: the allowlisted executor path can initiate external CALLs with computed targets and ETH value, so misconfiguration/compromise of the allowlist can drain contract-held assets.",
    "raw_final": {
        "summary": "One medium-risk issue: the allowlisted executor path can initiate external CALLs with computed targets and ETH value, so misconfiguration/compromise of the allowlist can drain contract-held assets.",
        "findings": [
            {
                "title": "Allowlisted executor can perform arbitrary external CALLs with ETH value",
                "category": "access_control",
                "evidence": "analysis_artifact.callsites show CALL with computed target/value (returndata_checked unknown) at pc 0x262/0x3f6/0x4be/0x66e/0x754/0xa4a/0xb61/0xcf6/0xe2b; detector_findings flag untrusted CALL target/value reachable. The allowlist check for canCallAddress[msg.sender] appears in the 0x069cb1d5 path before executing these calls.",
                "severity": "medium",
                "locations": [
                    "selector:0x069cb1d5",
                    "pc:0x262",
                    "pc:0x3f6",
                    "pc:0x4be",
                    "pc:0x66e",
                    "pc:0x754",
                    "pc:0xa4a",
                    "pc:0xb61",
                    "pc:0xcf6",
                    "pc:0xe2b"
                ],
                "recommendation": "Treat the allowlist as a critical control: limit it to trusted EOAs/contracts, use multisig/timelock for updates, and consider hard-allowlisting external targets (routers) or enforcing recipient/value caps. If the executor is intended to be general-purpose, document the trust model and keep contract balances minimal.",
                "exploit_scenario": "The selector at 0x069cb1d5 enforces a canCallAddress[msg.sender] allowlist, but once passed it executes multiple CALLs where target and value are computed from calldata. If the allowlist is misconfigured or a whitelisted key is compromised, the attacker can craft calldata to route tokens/ETH out of the contract (including ETH bribes via COINBASE) to arbitrary destinations, draining any balances held by the contract. Selector inference is best-effort from bytecode; the allowlist check is visible in the dispatcher/bytecode but higher-level intent is unknown."
            }
        ],
        "no_findings": false
    },
    "no_findings": false,
    "schema_version": 1
}

00000000: PUSH1 0x80
00000002: PUSH1 0x40
00000004: MSTORE
00000005: PUSH1 0x04
00000007: CALLDATASIZE
00000008: LT
00000009: PUSH2 0x0074
0000000c: JUMPI
0000000d: PUSH1 0x00
0000000f: CALLDATALOAD
00000010: PUSH1 0xe0
00000012: SHR
00000013: DUP1
00000014: PUSH4 0x6949e882
00000019: GT
0000001a: PUSH2 0x004e
0000001d: JUMPI
0000001e: DUP1
0000001f: PUSH4 0x6949e882
00000024: EQ
00000025: PUSH2 0x010f
00000028: JUMPI
00000029: DUP1
0000002a: PUSH4 0x8da5cb5b
0000002f: EQ
00000030: PUSH2 0x0138
00000033: JUMPI
00000034: DUP1
00000035: PUSH4 0xb6b55f25
0000003a: EQ
0000003b: PUSH2 0x0163
0000003e: JUMPI
0000003f: DUP1
00000040: PUSH4 0xdd0bea13
00000045: EQ
00000046: PUSH2 0x018c
00000049: JUMPI
0000004a: PUSH2 0x007b
0000004d: JUMP
0000004e: JUMPDEST
0000004f: DUP1
00000050: PUSH4 0x0368fb76
00000055: EQ
00000056: PUSH2 0x0080
00000059: JUMPI
0000005a: DUP1
0000005b: PUSH4 0x069cb1d5
00000060: EQ
00000061: PUSH2 0x00a9
00000064: JUMPI
00000065: DUP1
00000066: PUSH4 0x416669ed
0000006b: EQ
0000006c: PUSH2 0x00e6
0000006f: JUMPI
00000070: PUSH2 0x007b
00000073: JUMP
00000074: JUMPDEST
00000075: CALLDATASIZE
00000076: PUSH2 0x007b
00000079: JUMPI
0000007a: STOP
0000007b: JUMPDEST
0000007c: PUSH1 0x00
0000007e: DUP1
0000007f: REVERT
00000080: JUMPDEST
00000081: CALLVALUE
00000082: DUP1
00000083: ISZERO
00000084: PUSH2 0x008c
00000087: JUMPI
00000088: PUSH1 0x00
0000008a: DUP1
0000008b: REVERT
0000008c: JUMPDEST
0000008d: POP
0000008e: PUSH2 0x00a7
00000091: PUSH1 0x04
00000093: DUP1
00000094: CALLDATASIZE
00000095: SUB
00000096: DUP2
00000097: ADD
00000098: SWAP1
00000099: PUSH2 0x00a2
0000009c: SWAP2
0000009d: SWAP1
0000009e: PUSH2 0x12fb
000000a1: JUMP
000000a2: JUMPDEST
000000a3: PUSH2 0x01b5
000000a6: JUMP
000000a7: JUMPDEST
000000a8: STOP
000000a9: JUMPDEST
000000aa: CALLVALUE
000000ab: DUP1
000000ac: ISZERO
000000ad: PUSH2 0x00b5
000000b0: JUMPI
000000b1: PUSH1 0x00
000000b3: DUP1
000000b4: REVERT
000000b5: JUMPDEST
000000b6: POP
000000b7: PUSH2 0x00d0
000000ba: PUSH1 0x04
000000bc: DUP1
000000bd: CALLDATASIZE
000000be: SUB
000000bf: DUP2
000000c0: ADD
000000c1: SWAP1
000000c2: PUSH2 0x00cb
000000c5: SWAP2
000000c6: SWAP1
000000c7: PUSH2 0x11d4
000000ca: JUMP
000000cb: JUMPDEST
000000cc: PUSH2 0x029d
000000cf: JUMP
000000d0: JUMPDEST
000000d1: PUSH1 0x40
000000d3: MLOAD
000000d4: PUSH2 0x00dd
000000d7: SWAP2
000000d8: SWAP1
000000d9: PUSH2 0x1615
000000dc: JUMP
000000dd: JUMPDEST
000000de: PUSH1 0x40
000000e0: MLOAD
000000e1: DUP1
000000e2: SWAP2
000000e3: SUB
000000e4: SWAP1
000000e5: RETURN
000000e6: JUMPDEST
000000e7: CALLVALUE
000000e8: DUP1
000000e9: ISZERO
000000ea: PUSH2 0x00f2
000000ed: JUMPI
000000ee: PUSH1 0x00
000000f0: DUP1
000000f1: REVERT
000000f2: JUMPDEST
000000f3: POP
000000f4: PUSH2 0x010d
000000f7: PUSH1 0x04
000000f9: DUP1
000000fa: CALLDATASIZE
000000fb: SUB
000000fc: DUP2
000000fd: ADD
000000fe: SWAP1
000000ff: PUSH2 0x0108
00000102: SWAP2
00000103: SWAP1
00000104: PUSH2 0x134a
00000107: JUMP
00000108: JUMPDEST
00000109: PUSH2 0x0419
0000010c: JUMP
0000010d: JUMPDEST
0000010e: STOP
0000010f: JUMPDEST
00000110: CALLVALUE
00000111: DUP1
00000112: ISZERO
00000113: PUSH2 0x011b
00000116: JUMPI
00000117: PUSH1 0x00
00000119: DUP1
0000011a: REVERT
0000011b: JUMPDEST
0000011c: POP
0000011d: PUSH2 0x0136
00000120: PUSH1 0x04
00000122: DUP1
00000123: CALLDATASIZE
00000124: SUB
00000125: DUP2
00000126: ADD
00000127: SWAP1
00000128: PUSH2 0x0131
0000012b: SWAP2
0000012c: SWAP1
0000012d: PUSH2 0x1157
00000130: JUMP
00000131: JUMPDEST
00000132: PUSH2 0x04d8
00000135: JUMP
00000136: JUMPDEST
00000137: STOP
00000138: JUMPDEST
00000139: CALLVALUE
0000013a: DUP1
0000013b: ISZERO
0000013c: PUSH2 0x0144
0000013f: JUMPI
00000140: PUSH1 0x00
00000142: DUP1
00000143: REVERT
00000144: JUMPDEST
00000145: POP
00000146: PUSH2 0x014d
00000149: PUSH2 0x0588
0000014c: JUMP
0000014d: JUMPDEST
0000014e: PUSH1 0x40
00000150: MLOAD
00000151: PUSH2 0x015a
00000154: SWAP2
00000155: SWAP1
00000156: PUSH2 0x156c
00000159: JUMP
0000015a: JUMPDEST
0000015b: PUSH1 0x40
0000015d: MLOAD
0000015e: DUP1
0000015f: SWAP2
00000160: SUB
00000161: SWAP1
00000162: RETURN
00000163: JUMPDEST
00000164: CALLVALUE
00000165: DUP1
00000166: ISZERO
00000167: PUSH2 0x016f
0000016a: JUMPI
0000016b: PUSH1 0x00
0000016d: DUP1
0000016e: REVERT
0000016f: JUMPDEST
00000170: POP
00000171: PUSH2 0x018a
00000174: PUSH1 0x04
00000176: DUP1
00000177: CALLDATASIZE
00000178: SUB
00000179: DUP2
0000017a: ADD
0000017b: SWAP1
0000017c: PUSH2 0x0185
0000017f: SWAP2
00000180: SWAP1
00000181: PUSH2 0x134a
00000184: JUMP
00000185: JUMPDEST
00000186: PUSH2 0x05ac
00000189: JUMP
0000018a: JUMPDEST
0000018b: STOP
0000018c: JUMPDEST
0000018d: CALLVALUE
0000018e: DUP1
0000018f: ISZERO
00000190: PUSH2 0x0198
00000193: JUMPI
00000194: PUSH1 0x00
00000196: DUP1
00000197: REVERT
00000198: JUMPDEST
00000199: POP
0000019a: PUSH2 0x01b3
0000019d: PUSH1 0x04
0000019f: DUP1
000001a0: CALLDATASIZE
000001a1: SUB
000001a2: DUP2
000001a3: ADD
000001a4: SWAP1
000001a5: PUSH2 0x01ae
000001a8: SWAP2
000001a9: SWAP1
000001aa: PUSH2 0x134a
000001ad: JUMP
000001ae: JUMPDEST
000001af: PUSH2 0x0687
000001b2: JUMP
000001b3: JUMPDEST
000001b4: STOP
000001b5: JUMPDEST
000001b6: PUSH1 0x00
000001b8: DUP1
000001b9: SLOAD
000001ba: SWAP1
000001bb: PUSH2 0x0100
000001be: EXP
000001bf: SWAP1
000001c0: DIV
000001c1: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
000001d6: AND
000001d7: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
000001ec: AND
000001ed: CALLER
000001ee: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
00000203: AND
00000204: EQ
00000205: PUSH2 0x020a
00000208: JUMPI
00000209: INVALID
0000020a: JUMPDEST
0000020b: DUP3
0000020c: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
00000221: AND
00000222: PUSH4 0xa9059cbb
00000227: DUP4
00000228: DUP4
00000229: PUSH1 0x40
0000022b: MLOAD
0000022c: DUP4
0000022d: PUSH4 0xffffffff
00000232: AND
00000233: PUSH1 0xe0
00000235: SHL
00000236: DUP2
00000237: MSTORE
00000238: PUSH1 0x04
0000023a: ADD
0000023b: PUSH2 0x0245
0000023e: SWAP3
0000023f: SWAP2
00000240: SWAP1
00000241: PUSH2 0x15b0
00000244: JUMP
00000245: JUMPDEST
00000246: PUSH1 0x20
00000248: PUSH1 0x40
0000024a: MLOAD
0000024b: DUP1
0000024c: DUP4
0000024d: SUB
0000024e: DUP2
0000024f: PUSH1 0x00
00000251: DUP8
00000252: DUP1
00000253: EXTCODESIZE
00000254: ISZERO
00000255: DUP1
00000256: ISZERO
00000257: PUSH2 0x025f
0000025a: JUMPI
0000025b: PUSH1 0x00
0000025d: DUP1
0000025e: REVERT
0000025f: JUMPDEST
00000260: POP
00000261: GAS
00000262: CALL
00000263: ISZERO
00000264: DUP1
00000265: ISZERO
00000266: PUSH2 0x0273
00000269: JUMPI
0000026a: RETURNDATASIZE
0000026b: PUSH1 0x00
0000026d: DUP1
0000026e: RETURNDATACOPY
0000026f: RETURNDATASIZE
00000270: PUSH1 0x00
00000272: REVERT
00000273: JUMPDEST
00000274: POP
00000275: POP
00000276: POP
00000277: POP
00000278: PUSH1 0x40
0000027a: MLOAD
0000027b: RETURNDATASIZE
0000027c: PUSH1 0x1f
0000027e: NOT
0000027f: PUSH1 0x1f
00000281: DUP3
00000282: ADD
00000283: AND
00000284: DUP3
00000285: ADD
00000286: DUP1
00000287: PUSH1 0x40
00000289: MSTORE
0000028a: POP
0000028b: DUP2
0000028c: ADD
0000028d: SWAP1
0000028e: PUSH2 0x0297
00000291: SWAP2
00000292: SWAP1
00000293: PUSH2 0x12d2
00000296: JUMP
00000297: JUMPDEST
00000298: POP
00000299: POP
0000029a: POP
0000029b: POP
0000029c: JUMP
0000029d: JUMPDEST
0000029e: PUSH1 0x00
000002a0: PUSH1 0x01
000002a2: PUSH1 0x00
000002a4: CALLER
000002a5: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
000002ba: AND
000002bb: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
000002d0: AND
000002d1: DUP2
000002d2: MSTORE
000002d3: PUSH1 0x20
000002d5: ADD
000002d6: SWAP1
000002d7: DUP2
000002d8: MSTORE
000002d9: PUSH1 0x20
000002db: ADD
000002dc: PUSH1 0x00
000002de: KECCAK256
000002df: PUSH1 0x00
000002e1: SWAP1
000002e2: SLOAD
000002e3: SWAP1
000002e4: PUSH2 0x0100
000002e7: EXP
000002e8: SWAP1
000002e9: DIV
000002ea: PUSH1 0xff
000002ec: AND
000002ed: PUSH2 0x032b
000002f0: JUMPI
000002f1: PUSH1 0x40
000002f3: MLOAD
000002f4: PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000
00000315: DUP2
00000316: MSTORE
00000317: PUSH1 0x04
00000319: ADD
0000031a: PUSH2 0x0322
0000031d: SWAP1
0000031e: PUSH2 0x15d9
00000321: JUMP
00000322: JUMPDEST
00000323: PUSH1 0x40
00000325: MLOAD
00000326: DUP1
00000327: SWAP2
00000328: SUB
00000329: SWAP1
0000032a: REVERT
0000032b: JUMPDEST
0000032c: PUSH1 0x00
0000032e: JUMPDEST
0000032f: DUP9
00000330: MLOAD
00000331: DUP2
00000332: LT
00000333: ISZERO
00000334: PUSH2 0x03af
00000337: JUMPI
00000338: PUSH1 0x00
0000033a: DUP2
0000033b: GT
0000033c: ISZERO
0000033d: PUSH2 0x0344
00000340: JUMPI
00000341: DUP2
00000342: SWAP5
00000343: POP
00000344: JUMPDEST
00000345: PUSH2 0x03a0
00000348: DUP10
00000349: DUP3
0000034a: DUP2
0000034b: MLOAD
0000034c: DUP2
0000034d: LT
0000034e: PUSH2 0x0353
00000351: JUMPI
00000352: INVALID
00000353: JUMPDEST
00000354: PUSH1 0x20
00000356: MUL
00000357: PUSH1 0x20
00000359: ADD
0000035a: ADD
0000035b: MLOAD
0000035c: DUP10
0000035d: DUP4
0000035e: DUP2
0000035f: MLOAD
00000360: DUP2
00000361: LT
00000362: PUSH2 0x0367
00000365: JUMPI
00000366: INVALID
00000367: JUMPDEST
00000368: PUSH1 0x20
0000036a: MUL
0000036b: PUSH1 0x20
0000036d: ADD
0000036e: ADD
0000036f: MLOAD
00000370: DUP10
00000371: DUP5
00000372: DUP2
00000373: MLOAD
00000374: DUP2
00000375: LT
00000376: PUSH2 0x037b
00000379: JUMPI
0000037a: INVALID
0000037b: JUMPDEST
0000037c: PUSH1 0x20
0000037e: MUL
0000037f: PUSH1 0x20
00000381: ADD
00000382: ADD
00000383: MLOAD
00000384: DUP10
00000385: DUP6
00000386: DUP2
00000387: MLOAD
00000388: DUP2
00000389: LT
0000038a: PUSH2 0x038f
0000038d: JUMPI
0000038e: INVALID
0000038f: JUMPDEST
00000390: PUSH1 0x20
00000392: MUL
00000393: PUSH1 0x20
00000395: ADD
00000396: ADD
00000397: MLOAD
00000398: DUP10
00000399: PUSH1 0x00
0000039b: ADDRESS
0000039c: PUSH2 0x076c
0000039f: JUMP
000003a0: JUMPDEST
000003a1: SWAP2
000003a2: POP
000003a3: DUP1
000003a4: DUP1
000003a5: PUSH1 0x01
000003a7: ADD
000003a8: SWAP2
000003a9: POP
000003aa: POP
000003ab: PUSH2 0x032e
000003ae: JUMP
000003af: JUMPDEST
000003b0: POP
000003b1: DUP3
000003b2: DUP2
000003b3: LT
000003b4: ISZERO
000003b5: PUSH2 0x03bd
000003b8: JUMPI
000003b9: PUSH1 0x00
000003bb: DUP1
000003bc: REVERT
000003bd: JUMPDEST
000003be: PUSH1 0x00
000003c0: DUP3
000003c1: GT
000003c2: ISZERO
000003c3: PUSH2 0x040e
000003c6: JUMPI
000003c7: COINBASE
000003c8: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
000003dd: AND
000003de: PUSH2 0x08fc
000003e1: DUP4
000003e2: SWAP1
000003e3: DUP2
000003e4: ISZERO
000003e5: MUL
000003e6: SWAP1
000003e7: PUSH1 0x40
000003e9: MLOAD
000003ea: PUSH1 0x00
000003ec: PUSH1 0x40
000003ee: MLOAD
000003ef: DUP1
000003f0: DUP4
000003f1: SUB
000003f2: DUP2
000003f3: DUP6
000003f4: DUP9
000003f5: DUP9
000003f6: CALL
000003f7: SWAP4
000003f8: POP
000003f9: POP
000003fa: POP
000003fb: POP
000003fc: ISZERO
000003fd: DUP1
000003fe: ISZERO
000003ff: PUSH2 0x040c
00000402: JUMPI
00000403: RETURNDATASIZE
00000404: PUSH1 0x00
00000406: DUP1
00000407: RETURNDATACOPY
00000408: RETURNDATASIZE
00000409: PUSH1 0x00
0000040b: REVERT
0000040c: JUMPDEST
0000040d: POP
0000040e: JUMPDEST
0000040f: SWAP8
00000410: SWAP7
00000411: POP
00000412: POP
00000413: POP
00000414: POP
00000415: POP
00000416: POP
00000417: POP
00000418: JUMP
00000419: JUMPDEST
0000041a: PUSH1 0x00
0000041c: DUP1
0000041d: SLOAD
0000041e: SWAP1
0000041f: PUSH2 0x0100
00000422: EXP
00000423: SWAP1
00000424: DIV
00000425: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
0000043a: AND
0000043b: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
00000450: AND
00000451: CALLER
00000452: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
00000467: AND
00000468: EQ
00000469: PUSH2 0x046e
0000046c: JUMPI
0000046d: INVALID
0000046e: JUMPDEST
0000046f: PUSH1 0x00
00000471: DUP1
00000472: SLOAD
00000473: SWAP1
00000474: PUSH2 0x0100
00000477: EXP
00000478: SWAP1
00000479: DIV
0000047a: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
0000048f: AND
00000490: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
000004a5: AND
000004a6: PUSH2 0x08fc
000004a9: DUP3
000004aa: SWAP1
000004ab: DUP2
000004ac: ISZERO
000004ad: MUL
000004ae: SWAP1
000004af: PUSH1 0x40
000004b1: MLOAD
000004b2: PUSH1 0x00
000004b4: PUSH1 0x40
000004b6: MLOAD
000004b7: DUP1
000004b8: DUP4
000004b9: SUB
000004ba: DUP2
000004bb: DUP6
000004bc: DUP9
000004bd: DUP9
000004be: CALL
000004bf: SWAP4
000004c0: POP
000004c1: POP
000004c2: POP
000004c3: POP
000004c4: ISZERO
000004c5: DUP1
000004c6: ISZERO
000004c7: PUSH2 0x04d4
000004ca: JUMPI
000004cb: RETURNDATASIZE
000004cc: PUSH1 0x00
000004ce: DUP1
000004cf: RETURNDATACOPY
000004d0: RETURNDATASIZE
000004d1: PUSH1 0x00
000004d3: REVERT
000004d4: JUMPDEST
000004d5: POP
000004d6: POP
000004d7: JUMP
000004d8: JUMPDEST
000004d9: PUSH1 0x00
000004db: DUP1
000004dc: SLOAD
000004dd: SWAP1
000004de: PUSH2 0x0100
000004e1: EXP
000004e2: SWAP1
000004e3: DIV
000004e4: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
000004f9: AND
000004fa: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
0000050f: AND
00000510: CALLER
00000511: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
00000526: AND
00000527: EQ
00000528: PUSH2 0x052d
0000052b: JUMPI
0000052c: INVALID
0000052d: JUMPDEST
0000052e: DUP1
0000052f: PUSH1 0x01
00000531: PUSH1 0x00
00000533: DUP5
00000534: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
00000549: AND
0000054a: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
0000055f: AND
00000560: DUP2
00000561: MSTORE
00000562: PUSH1 0x20
00000564: ADD
00000565: SWAP1
00000566: DUP2
00000567: MSTORE
00000568: PUSH1 0x20
0000056a: ADD
0000056b: PUSH1 0x00
0000056d: KECCAK256
0000056e: PUSH1 0x00
00000570: PUSH2 0x0100
00000573: EXP
00000574: DUP2
00000575: SLOAD
00000576: DUP2
00000577: PUSH1 0xff
00000579: MUL
0000057a: NOT
0000057b: AND
0000057c: SWAP1
0000057d: DUP4
0000057e: ISZERO
0000057f: ISZERO
00000580: MUL
00000581: OR
00000582: SWAP1
00000583: SSTORE
00000584: POP
00000585: POP
00000586: POP
00000587: JUMP
00000588: JUMPDEST
00000589: PUSH1 0x00
0000058b: DUP1
0000058c: SLOAD
0000058d: SWAP1
0000058e: PUSH2 0x0100
00000591: EXP
00000592: SWAP1
00000593: DIV
00000594: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
000005a9: AND
000005aa: DUP2
000005ab: JUMP
000005ac: JUMPDEST
000005ad: PUSH1 0x00
000005af: DUP1
000005b0: SLOAD
000005b1: SWAP1
000005b2: PUSH2 0x0100
000005b5: EXP
000005b6: SWAP1
000005b7: DIV
000005b8: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
000005cd: AND
000005ce: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
000005e3: AND
000005e4: CALLER
000005e5: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
000005fa: AND
000005fb: EQ
000005fc: PUSH2 0x0601
000005ff: JUMPI
00000600: INVALID
00000601: JUMPDEST
00000602: PUSH1 0x02
00000604: PUSH1 0x00
00000606: SWAP1
00000607: SLOAD
00000608: SWAP1
00000609: PUSH2 0x0100
0000060c: EXP
0000060d: SWAP1
0000060e: DIV
0000060f: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
00000624: AND
00000625: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
0000063a: AND
0000063b: PUSH4 0xd0e30db0
00000640: DUP3
00000641: PUSH1 0x40
00000643: MLOAD
00000644: DUP3
00000645: PUSH4 0xffffffff
0000064a: AND
0000064b: PUSH1 0xe0
0000064d: SHL
0000064e: DUP2
0000064f: MSTORE
00000650: PUSH1 0x04
00000652: ADD
00000653: PUSH1 0x00
00000655: PUSH1 0x40
00000657: MLOAD
00000658: DUP1
00000659: DUP4
0000065a: SUB
0000065b: DUP2
0000065c: DUP6
0000065d: DUP9
0000065e: DUP1
0000065f: EXTCODESIZE
00000660: ISZERO
00000661: DUP1
00000662: ISZERO
00000663: PUSH2 0x066b
00000666: JUMPI
00000667: PUSH1 0x00
00000669: DUP1
0000066a: REVERT
0000066b: JUMPDEST
0000066c: POP
0000066d: GAS
0000066e: CALL
0000066f: ISZERO
00000670: DUP1
00000671: ISZERO
00000672: PUSH2 0x067f
00000675: JUMPI
00000676: RETURNDATASIZE
00000677: PUSH1 0x00
00000679: DUP1
0000067a: RETURNDATACOPY
0000067b: RETURNDATASIZE
0000067c: PUSH1 0x00
0000067e: REVERT
0000067f: JUMPDEST
00000680: POP
00000681: POP
00000682: POP
00000683: POP
00000684: POP
00000685: POP
00000686: JUMP
00000687: JUMPDEST
00000688: PUSH1 0x00
0000068a: DUP1
0000068b: SLOAD
0000068c: SWAP1
0000068d: PUSH2 0x0100
00000690: EXP
00000691: SWAP1
00000692: DIV
00000693: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
000006a8: AND
000006a9: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
000006be: AND
000006bf: CALLER
000006c0: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
000006d5: AND
000006d6: EQ
000006d7: PUSH2 0x06dc
000006da: JUMPI
000006db: INVALID
000006dc: JUMPDEST
000006dd: PUSH1 0x02
000006df: PUSH1 0x00
000006e1: SWAP1
000006e2: SLOAD
000006e3: SWAP1
000006e4: PUSH2 0x0100
000006e7: EXP
000006e8: SWAP1
000006e9: DIV
000006ea: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
000006ff: AND
00000700: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
00000715: AND
00000716: PUSH4 0x2e1a7d4d
0000071b: DUP3
0000071c: PUSH1 0x40
0000071e: MLOAD
0000071f: DUP3
00000720: PUSH4 0xffffffff
00000725: AND
00000726: PUSH1 0xe0
00000728: SHL
00000729: DUP2
0000072a: MSTORE
0000072b: PUSH1 0x04
0000072d: ADD
0000072e: PUSH2 0x0737
00000731: SWAP2
00000732: SWAP1
00000733: PUSH2 0x1615
00000736: JUMP
00000737: JUMPDEST
00000738: PUSH1 0x00
0000073a: PUSH1 0x40
0000073c: MLOAD
0000073d: DUP1
0000073e: DUP4
0000073f: SUB
00000740: DUP2
00000741: PUSH1 0x00
00000743: DUP8
00000744: DUP1
00000745: EXTCODESIZE
00000746: ISZERO
00000747: DUP1
00000748: ISZERO
00000749: PUSH2 0x0751
0000074c: JUMPI
0000074d: PUSH1 0x00
0000074f: DUP1
00000750: REVERT
00000751: JUMPDEST
00000752: POP
00000753: GAS
00000754: CALL
00000755: ISZERO
00000756: DUP1
00000757: ISZERO
00000758: PUSH2 0x0765
0000075b: JUMPI
0000075c: RETURNDATASIZE
0000075d: PUSH1 0x00
0000075f: DUP1
00000760: RETURNDATACOPY
00000761: RETURNDATASIZE
00000762: PUSH1 0x00
00000764: REVERT
00000765: JUMPDEST
00000766: POP
00000767: POP
00000768: POP
00000769: POP
0000076a: POP
0000076b: JUMP
0000076c: JUMPDEST
0000076d: PUSH1 0x00
0000076f: DUP8
00000770: PUSH1 0x01
00000772: EQ
00000773: ISZERO
00000774: PUSH2 0x086b
00000777: JUMPI
00000778: PUSH1 0x00
0000077a: PUSH1 0x02
0000077c: PUSH8 0xffffffffffffffff
00000785: DUP2
00000786: GT
00000787: DUP1
00000788: ISZERO
00000789: PUSH2 0x0791
0000078c: JUMPI
0000078d: PUSH1 0x00
0000078f: DUP1
00000790: REVERT
00000791: JUMPDEST
00000792: POP
00000793: PUSH1 0x40
00000795: MLOAD
00000796: SWAP1
00000797: DUP1
00000798: DUP3
00000799: MSTORE
0000079a: DUP1
0000079b: PUSH1 0x20
0000079d: MUL
0000079e: PUSH1 0x20
000007a0: ADD
000007a1: DUP3
000007a2: ADD
000007a3: PUSH1 0x40
000007a5: MSTORE
000007a6: DUP1
000007a7: ISZERO
000007a8: PUSH2 0x07c0
000007ab: JUMPI
000007ac: DUP2
000007ad: PUSH1 0x20
000007af: ADD
000007b0: PUSH1 0x20
000007b2: DUP3
000007b3: MUL
000007b4: DUP1
000007b5: CALLDATASIZE
000007b6: DUP4
000007b7: CALLDATACOPY
000007b8: DUP1
000007b9: DUP3
000007ba: ADD
000007bb: SWAP2
000007bc: POP
000007bd: POP
000007be: SWAP1
000007bf: POP
000007c0: JUMPDEST
000007c1: POP
000007c2: SWAP1
000007c3: POP
000007c4: DUP8
000007c5: DUP2
000007c6: PUSH1 0x00
000007c8: DUP2
000007c9: MLOAD
000007ca: DUP2
000007cb: LT
000007cc: PUSH2 0x07d1
000007cf: JUMPI
000007d0: INVALID
000007d1: JUMPDEST
000007d2: PUSH1 0x20
000007d4: MUL
000007d5: PUSH1 0x20
000007d7: ADD
000007d8: ADD
000007d9: SWAP1
000007da: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
000007ef: AND
000007f0: SWAP1
000007f1: DUP2
000007f2: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
00000807: AND
00000808: DUP2
00000809: MSTORE
0000080a: POP
0000080b: POP
0000080c: DUP7
0000080d: DUP2
0000080e: PUSH1 0x01
00000810: DUP2
00000811: MLOAD
00000812: DUP2
00000813: LT
00000814: PUSH2 0x0819
00000817: JUMPI
00000818: INVALID
00000819: JUMPDEST
0000081a: PUSH1 0x20
0000081c: MUL
0000081d: PUSH1 0x20
0000081f: ADD
00000820: ADD
00000821: SWAP1
00000822: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
00000837: AND
00000838: SWAP1
00000839: DUP2
0000083a: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
0000084f: AND
00000850: DUP2
00000851: MSTORE
00000852: POP
00000853: POP
00000854: PUSH2 0x0863
00000857: DUP6
00000858: DUP6
00000859: DUP4
0000085a: DUP7
0000085b: PUSH1 0x1e
0000085d: TIMESTAMP
0000085e: ADD
0000085f: PUSH2 0x0993
00000862: JUMP
00000863: JUMPDEST
00000864: SWAP2
00000865: POP
00000866: POP
00000867: PUSH2 0x0988
0000086a: JUMP
0000086b: JUMPDEST
0000086c: DUP8
0000086d: PUSH1 0x02
0000086f: EQ
00000870: ISZERO
00000871: PUSH2 0x0968
00000874: JUMPI
00000875: PUSH1 0x00
00000877: PUSH1 0x02
00000879: PUSH8 0xffffffffffffffff
00000882: DUP2
00000883: GT
00000884: DUP1
00000885: ISZERO
00000886: PUSH2 0x088e
00000889: JUMPI
0000088a: PUSH1 0x00
0000088c: DUP1
0000088d: REVERT
0000088e: JUMPDEST
0000088f: POP
00000890: PUSH1 0x40
00000892: MLOAD
00000893: SWAP1
00000894: DUP1
00000895: DUP3
00000896: MSTORE
00000897: DUP1
00000898: PUSH1 0x20
0000089a: MUL
0000089b: PUSH1 0x20
0000089d: ADD
0000089e: DUP3
0000089f: ADD
000008a0: PUSH1 0x40
000008a2: MSTORE
000008a3: DUP1
000008a4: ISZERO
000008a5: PUSH2 0x08bd
000008a8: JUMPI
000008a9: DUP2
000008aa: PUSH1 0x20
000008ac: ADD
000008ad: PUSH1 0x20
000008af: DUP3
000008b0: MUL
000008b1: DUP1
000008b2: CALLDATASIZE
000008b3: DUP4
000008b4: CALLDATACOPY
000008b5: DUP1
000008b6: DUP3
000008b7: ADD
000008b8: SWAP2
000008b9: POP
000008ba: POP
000008bb: SWAP1
000008bc: POP
000008bd: JUMPDEST
000008be: POP
000008bf: SWAP1
000008c0: POP
000008c1: DUP8
000008c2: DUP2
000008c3: PUSH1 0x00
000008c5: DUP2
000008c6: MLOAD
000008c7: DUP2
000008c8: LT
000008c9: PUSH2 0x08ce
000008cc: JUMPI
000008cd: INVALID
000008ce: JUMPDEST
000008cf: PUSH1 0x20
000008d1: MUL
000008d2: PUSH1 0x20
000008d4: ADD
000008d5: ADD
000008d6: SWAP1
000008d7: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
000008ec: AND
000008ed: SWAP1
000008ee: DUP2
000008ef: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
00000904: AND
00000905: DUP2
00000906: MSTORE
00000907: POP
00000908: POP
00000909: DUP7
0000090a: DUP2
0000090b: PUSH1 0x01
0000090d: DUP2
0000090e: MLOAD
0000090f: DUP2
00000910: LT
00000911: PUSH2 0x0916
00000914: JUMPI
00000915: INVALID
00000916: JUMPDEST
00000917: PUSH1 0x20
00000919: MUL
0000091a: PUSH1 0x20
0000091c: ADD
0000091d: ADD
0000091e: SWAP1
0000091f: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
00000934: AND
00000935: SWAP1
00000936: DUP2
00000937: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
0000094c: AND
0000094d: DUP2
0000094e: MSTORE
0000094f: POP
00000950: POP
00000951: PUSH2 0x0960
00000954: DUP6
00000955: DUP6
00000956: DUP4
00000957: DUP7
00000958: PUSH1 0x1e
0000095a: TIMESTAMP
0000095b: ADD
0000095c: PUSH2 0x0aaa
0000095f: JUMP
00000960: JUMPDEST
00000961: SWAP2
00000962: POP
00000963: POP
00000964: PUSH2 0x0987
00000967: JUMP
00000968: JUMPDEST
00000969: DUP8
0000096a: PUSH1 0x03
0000096c: EQ
0000096d: ISZERO
0000096e: PUSH2 0x0986
00000971: JUMPI
00000972: PUSH2 0x0983
00000975: DUP5
00000976: DUP5
00000977: DUP10
00000978: DUP10
00000979: DUP10
0000097a: DUP8
0000097b: PUSH1 0x1e
0000097d: TIMESTAMP
0000097e: ADD
0000097f: PUSH2 0x0bc1
00000982: JUMP
00000983: JUMPDEST
00000984: SWAP1
00000985: POP
00000986: JUMPDEST
00000987: JUMPDEST
00000988: JUMPDEST
00000989: SWAP8
0000098a: SWAP7
0000098b: POP
0000098c: POP
0000098d: POP
0000098e: POP
0000098f: POP
00000990: POP
00000991: POP
00000992: JUMP
00000993: JUMPDEST
00000994: PUSH1 0x00
00000996: PUSH2 0x09c8
00000999: DUP5
0000099a: PUSH1 0x00
0000099c: DUP2
0000099d: MLOAD
0000099e: DUP2
0000099f: LT
000009a0: PUSH2 0x09a5
000009a3: JUMPI
000009a4: INVALID
000009a5: JUMPDEST
000009a6: PUSH1 0x20
000009a8: MUL
000009a9: PUSH1 0x20
000009ab: ADD
000009ac: ADD
000009ad: MLOAD
000009ae: PUSH20 0xd9e1ce17f2641f24ae83637ab66a2cca9c378b9f
000009c3: DUP9
000009c4: PUSH2 0x0d3a
000009c7: JUMP
000009c8: JUMPDEST
000009c9: PUSH1 0x00
000009cb: PUSH1 0x03
000009cd: PUSH1 0x00
000009cf: SWAP1
000009d0: SLOAD
000009d1: SWAP1
000009d2: PUSH2 0x0100
000009d5: EXP
000009d6: SWAP1
000009d7: DIV
000009d8: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
000009ed: AND
000009ee: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
00000a03: AND
00000a04: PUSH4 0x5c11d795
00000a09: DUP9
00000a0a: DUP9
00000a0b: DUP9
00000a0c: DUP9
00000a0d: DUP9
00000a0e: PUSH1 0x40
00000a10: MLOAD
00000a11: DUP7
00000a12: PUSH4 0xffffffff
00000a17: AND
00000a18: PUSH1 0xe0
00000a1a: SHL
00000a1b: DUP2
00000a1c: MSTORE
00000a1d: PUSH1 0x04
00000a1f: ADD
00000a20: PUSH2 0x0a2d
00000a23: SWAP6
00000a24: SWAP5
00000a25: SWAP4
00000a26: SWAP3
00000a27: SWAP2
00000a28: SWAP1
00000a29: PUSH2 0x1630
00000a2c: JUMP
00000a2d: JUMPDEST
00000a2e: PUSH1 0x00
00000a30: PUSH1 0x40
00000a32: MLOAD
00000a33: DUP1
00000a34: DUP4
00000a35: SUB
00000a36: DUP2
00000a37: PUSH1 0x00
00000a39: DUP8
00000a3a: DUP1
00000a3b: EXTCODESIZE
00000a3c: ISZERO
00000a3d: DUP1
00000a3e: ISZERO
00000a3f: PUSH2 0x0a47
00000a42: JUMPI
00000a43: PUSH1 0x00
00000a45: DUP1
00000a46: REVERT
00000a47: JUMPDEST
00000a48: POP
00000a49: GAS
00000a4a: CALL
00000a4b: ISZERO
00000a4c: DUP1
00000a4d: ISZERO
00000a4e: PUSH2 0x0a5b
00000a51: JUMPI
00000a52: RETURNDATASIZE
00000a53: PUSH1 0x00
00000a55: DUP1
00000a56: RETURNDATACOPY
00000a57: RETURNDATASIZE
00000a58: PUSH1 0x00
00000a5a: REVERT
00000a5b: JUMPDEST
00000a5c: POP
00000a5d: POP
00000a5e: POP
00000a5f: POP
00000a60: PUSH1 0x40
00000a62: MLOAD
00000a63: RETURNDATASIZE
00000a64: PUSH1 0x00
00000a66: DUP3
00000a67: RETURNDATACOPY
00000a68: RETURNDATASIZE
00000a69: PUSH1 0x1f
00000a6b: NOT
00000a6c: PUSH1 0x1f
00000a6e: DUP3
00000a6f: ADD
00000a70: AND
00000a71: DUP3
00000a72: ADD
00000a73: DUP1
00000a74: PUSH1 0x40
00000a76: MSTORE
00000a77: POP
00000a78: DUP2
00000a79: ADD
00000a7a: SWAP1
00000a7b: PUSH2 0x0a84
00000a7e: SWAP2
00000a7f: SWAP1
00000a80: PUSH2 0x1193
00000a83: JUMP
00000a84: JUMPDEST
00000a85: SWAP1
00000a86: POP
00000a87: DUP1
00000a88: PUSH1 0x01
00000a8a: DUP3
00000a8b: MLOAD
00000a8c: SUB
00000a8d: DUP2
00000a8e: MLOAD
00000a8f: DUP2
00000a90: LT
00000a91: PUSH2 0x0a96
00000a94: JUMPI
00000a95: INVALID
00000a96: JUMPDEST
00000a97: PUSH1 0x20
00000a99: MUL
00000a9a: PUSH1 0x20
00000a9c: ADD
00000a9d: ADD
00000a9e: MLOAD
00000a9f: SWAP2
00000aa0: POP
00000aa1: POP
00000aa2: SWAP6
00000aa3: SWAP5
00000aa4: POP
00000aa5: POP
00000aa6: POP
00000aa7: POP
00000aa8: POP
00000aa9: JUMP
00000aaa: JUMPDEST
00000aab: PUSH1 0x00
00000aad: PUSH2 0x0adf
00000ab0: DUP5
00000ab1: PUSH1 0x00
00000ab3: DUP2
00000ab4: MLOAD
00000ab5: DUP2
00000ab6: LT
00000ab7: PUSH2 0x0abc
00000aba: JUMPI
00000abb: INVALID
00000abc: JUMPDEST
00000abd: PUSH1 0x20
00000abf: MUL
00000ac0: PUSH1 0x20
00000ac2: ADD
00000ac3: ADD
00000ac4: MLOAD
00000ac5: PUSH20 0x7a250d5630b4cf539739df2c5dacb4c659f2488d
00000ada: DUP9
00000adb: PUSH2 0x0d3a
00000ade: JUMP
00000adf: JUMPDEST
00000ae0: PUSH1 0x00
00000ae2: PUSH1 0x04
00000ae4: PUSH1 0x00
00000ae6: SWAP1
00000ae7: SLOAD
00000ae8: SWAP1
00000ae9: PUSH2 0x0100
00000aec: EXP
00000aed: SWAP1
00000aee: DIV
00000aef: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
00000b04: AND
00000b05: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
00000b1a: AND
00000b1b: PUSH4 0x5c11d795
00000b20: DUP9
00000b21: DUP9
00000b22: DUP9
00000b23: DUP9
00000b24: DUP9
00000b25: PUSH1 0x40
00000b27: MLOAD
00000b28: DUP7
00000b29: PUSH4 0xffffffff
00000b2e: AND
00000b2f: PUSH1 0xe0
00000b31: SHL
00000b32: DUP2
00000b33: MSTORE
00000b34: PUSH1 0x04
00000b36: ADD
00000b37: PUSH2 0x0b44
00000b3a: SWAP6
00000b3b: SWAP5
00000b3c: SWAP4
00000b3d: SWAP3
00000b3e: SWAP2
00000b3f: SWAP1
00000b40: PUSH2 0x1630
00000b43: JUMP
00000b44: JUMPDEST
00000b45: PUSH1 0x00
00000b47: PUSH1 0x40
00000b49: MLOAD
00000b4a: DUP1
00000b4b: DUP4
00000b4c: SUB
00000b4d: DUP2
00000b4e: PUSH1 0x00
00000b50: DUP8
00000b51: DUP1
00000b52: EXTCODESIZE
00000b53: ISZERO
00000b54: DUP1
00000b55: ISZERO
00000b56: PUSH2 0x0b5e
00000b59: JUMPI
00000b5a: PUSH1 0x00
00000b5c: DUP1
00000b5d: REVERT
00000b5e: JUMPDEST
00000b5f: POP
00000b60: GAS
00000b61: CALL
00000b62: ISZERO
00000b63: DUP1
00000b64: ISZERO
00000b65: PUSH2 0x0b72
00000b68: JUMPI
00000b69: RETURNDATASIZE
00000b6a: PUSH1 0x00
00000b6c: DUP1
00000b6d: RETURNDATACOPY
00000b6e: RETURNDATASIZE
00000b6f: PUSH1 0x00
00000b71: REVERT
00000b72: JUMPDEST
00000b73: POP
00000b74: POP
00000b75: POP
00000b76: POP
00000b77: PUSH1 0x40
00000b79: MLOAD
00000b7a: RETURNDATASIZE
00000b7b: PUSH1 0x00
00000b7d: DUP3
00000b7e: RETURNDATACOPY
00000b7f: RETURNDATASIZE
00000b80: PUSH1 0x1f
00000b82: NOT
00000b83: PUSH1 0x1f
00000b85: DUP3
00000b86: ADD
00000b87: AND
00000b88: DUP3
00000b89: ADD
00000b8a: DUP1
00000b8b: PUSH1 0x40
00000b8d: MSTORE
00000b8e: POP
00000b8f: DUP2
00000b90: ADD
00000b91: SWAP1
00000b92: PUSH2 0x0b9b
00000b95: SWAP2
00000b96: SWAP1
00000b97: PUSH2 0x1193
00000b9a: JUMP
00000b9b: JUMPDEST
00000b9c: SWAP1
00000b9d: POP
00000b9e: DUP1
00000b9f: PUSH1 0x01
00000ba1: DUP3
00000ba2: MLOAD
00000ba3: SUB
00000ba4: DUP2
00000ba5: MLOAD
00000ba6: DUP2
00000ba7: LT
00000ba8: PUSH2 0x0bad
00000bab: JUMPI
00000bac: INVALID
00000bad: JUMPDEST
00000bae: PUSH1 0x20
00000bb0: MUL
00000bb1: PUSH1 0x20
00000bb3: ADD
00000bb4: ADD
00000bb5: MLOAD
00000bb6: SWAP2
00000bb7: POP
00000bb8: POP
00000bb9: SWAP6
00000bba: SWAP5
00000bbb: POP
00000bbc: POP
00000bbd: POP
00000bbe: POP
00000bbf: POP
00000bc0: JUMP
00000bc1: JUMPDEST
00000bc2: PUSH1 0x00
00000bc4: PUSH2 0x0be2
00000bc7: DUP7
00000bc8: PUSH20 0xe592427a0aece92de3edee1f18e0157c05861564
00000bdd: DUP11
00000bde: PUSH2 0x0d3a
00000be1: JUMP
00000be2: JUMPDEST
00000be3: PUSH1 0x00
00000be5: DUP1
00000be6: PUSH1 0x40
00000be8: MLOAD
00000be9: DUP1
00000bea: PUSH2 0x0100
00000bed: ADD
00000bee: PUSH1 0x40
00000bf0: MSTORE
00000bf1: DUP1
00000bf2: DUP10
00000bf3: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
00000c08: AND
00000c09: DUP2
00000c0a: MSTORE
00000c0b: PUSH1 0x20
00000c0d: ADD
00000c0e: DUP9
00000c0f: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
00000c24: AND
00000c25: DUP2
00000c26: MSTORE
00000c27: PUSH1 0x20
00000c29: ADD
00000c2a: DUP8
00000c2b: PUSH3 0xffffff
00000c2f: AND
00000c30: DUP2
00000c31: MSTORE
00000c32: PUSH1 0x20
00000c34: ADD
00000c35: DUP7
00000c36: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
00000c4b: AND
00000c4c: DUP2
00000c4d: MSTORE
00000c4e: PUSH1 0x20
00000c50: ADD
00000c51: DUP6
00000c52: DUP2
00000c53: MSTORE
00000c54: PUSH1 0x20
00000c56: ADD
00000c57: DUP12
00000c58: DUP2
00000c59: MSTORE
00000c5a: PUSH1 0x20
00000c5c: ADD
00000c5d: DUP11
00000c5e: DUP2
00000c5f: MSTORE
00000c60: PUSH1 0x20
00000c62: ADD
00000c63: DUP4
00000c64: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
00000c79: AND
00000c7a: DUP2
00000c7b: MSTORE
00000c7c: POP
00000c7d: SWAP1
00000c7e: POP
00000c7f: PUSH1 0x05
00000c81: PUSH1 0x00
00000c83: SWAP1
00000c84: SLOAD
00000c85: SWAP1
00000c86: PUSH2 0x0100
00000c89: EXP
00000c8a: SWAP1
00000c8b: DIV
00000c8c: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
00000ca1: AND
00000ca2: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
00000cb7: AND
00000cb8: PUSH4 0x414bf389
00000cbd: DUP3
00000cbe: PUSH1 0x40
00000cc0: MLOAD
00000cc1: DUP3
00000cc2: PUSH4 0xffffffff
00000cc7: AND
00000cc8: PUSH1 0xe0
00000cca: SHL
00000ccb: DUP2
00000ccc: MSTORE
00000ccd: PUSH1 0x04
00000ccf: ADD
00000cd0: PUSH2 0x0cd9
00000cd3: SWAP2
00000cd4: SWAP1
00000cd5: PUSH2 0x15f9
00000cd8: JUMP
00000cd9: JUMPDEST
00000cda: PUSH1 0x20
00000cdc: PUSH1 0x40
00000cde: MLOAD
00000cdf: DUP1
00000ce0: DUP4
00000ce1: SUB
00000ce2: DUP2
00000ce3: PUSH1 0x00
00000ce5: DUP8
00000ce6: DUP1
00000ce7: EXTCODESIZE
00000ce8: ISZERO
00000ce9: DUP1
00000cea: ISZERO
00000ceb: PUSH2 0x0cf3
00000cee: JUMPI
00000cef: PUSH1 0x00
00000cf1: DUP1
00000cf2: REVERT
00000cf3: JUMPDEST
00000cf4: POP
00000cf5: GAS
00000cf6: CALL
00000cf7: ISZERO
00000cf8: DUP1
00000cf9: ISZERO
00000cfa: PUSH2 0x0d07
00000cfd: JUMPI
00000cfe: RETURNDATASIZE
00000cff: PUSH1 0x00
00000d01: DUP1
00000d02: RETURNDATACOPY
00000d03: RETURNDATASIZE
00000d04: PUSH1 0x00
00000d06: REVERT
00000d07: JUMPDEST
00000d08: POP
00000d09: POP
00000d0a: POP
00000d0b: POP
00000d0c: PUSH1 0x40
00000d0e: MLOAD
00000d0f: RETURNDATASIZE
00000d10: PUSH1 0x1f
00000d12: NOT
00000d13: PUSH1 0x1f
00000d15: DUP3
00000d16: ADD
00000d17: AND
00000d18: DUP3
00000d19: ADD
00000d1a: DUP1
00000d1b: PUSH1 0x40
00000d1d: MSTORE
00000d1e: POP
00000d1f: DUP2
00000d20: ADD
00000d21: SWAP1
00000d22: PUSH2 0x0d2b
00000d25: SWAP2
00000d26: SWAP1
00000d27: PUSH2 0x1373
00000d2a: JUMP
00000d2b: JUMPDEST
00000d2c: SWAP3
00000d2d: POP
00000d2e: POP
00000d2f: POP
00000d30: SWAP8
00000d31: SWAP7
00000d32: POP
00000d33: POP
00000d34: POP
00000d35: POP
00000d36: POP
00000d37: POP
00000d38: POP
00000d39: JUMP
00000d3a: JUMPDEST
00000d3b: DUP1
00000d3c: DUP4
00000d3d: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
00000d52: AND
00000d53: PUSH4 0xdd62ed3e
00000d58: ADDRESS
00000d59: DUP6
00000d5a: PUSH1 0x40
00000d5c: MLOAD
00000d5d: DUP4
00000d5e: PUSH4 0xffffffff
00000d63: AND
00000d64: PUSH1 0xe0
00000d66: SHL
00000d67: DUP2
00000d68: MSTORE
00000d69: PUSH1 0x04
00000d6b: ADD
00000d6c: PUSH2 0x0d76
00000d6f: SWAP3
00000d70: SWAP2
00000d71: SWAP1
00000d72: PUSH2 0x1587
00000d75: JUMP
00000d76: JUMPDEST
00000d77: PUSH1 0x20
00000d79: PUSH1 0x40
00000d7b: MLOAD
00000d7c: DUP1
00000d7d: DUP4
00000d7e: SUB
00000d7f: DUP2
00000d80: DUP7
00000d81: DUP1
00000d82: EXTCODESIZE
00000d83: ISZERO
00000d84: DUP1
00000d85: ISZERO
00000d86: PUSH2 0x0d8e
00000d89: JUMPI
00000d8a: PUSH1 0x00
00000d8c: DUP1
00000d8d: REVERT
00000d8e: JUMPDEST
00000d8f: POP
00000d90: GAS
00000d91: STATICCALL
00000d92: ISZERO
00000d93: DUP1
00000d94: ISZERO
00000d95: PUSH2 0x0da2
00000d98: JUMPI
00000d99: RETURNDATASIZE
00000d9a: PUSH1 0x00
00000d9c: DUP1
00000d9d: RETURNDATACOPY
00000d9e: RETURNDATASIZE
00000d9f: PUSH1 0x00
00000da1: REVERT
00000da2: JUMPDEST
00000da3: POP
00000da4: POP
00000da5: POP
00000da6: POP
00000da7: PUSH1 0x40
00000da9: MLOAD
00000daa: RETURNDATASIZE
00000dab: PUSH1 0x1f
00000dad: NOT
00000dae: PUSH1 0x1f
00000db0: DUP3
00000db1: ADD
00000db2: AND
00000db3: DUP3
00000db4: ADD
00000db5: DUP1
00000db6: PUSH1 0x40
00000db8: MSTORE
00000db9: POP
00000dba: DUP2
00000dbb: ADD
00000dbc: SWAP1
00000dbd: PUSH2 0x0dc6
00000dc0: SWAP2
00000dc1: SWAP1
00000dc2: PUSH2 0x1373
00000dc5: JUMP
00000dc6: JUMPDEST
00000dc7: LT
00000dc8: PUSH2 0x0dd0
00000dcb: JUMPI
00000dcc: PUSH2 0x0e67
00000dcf: JUMP
00000dd0: JUMPDEST
00000dd1: DUP3
00000dd2: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
00000de7: AND
00000de8: PUSH4 0x095ea7b3
00000ded: DUP4
00000dee: PUSH1 0x64
00000df0: DUP5
00000df1: MUL
00000df2: PUSH1 0x40
00000df4: MLOAD
00000df5: DUP4
00000df6: PUSH4 0xffffffff
00000dfb: AND
00000dfc: PUSH1 0xe0
00000dfe: SHL
00000dff: DUP2
00000e00: MSTORE
00000e01: PUSH1 0x04
00000e03: ADD
00000e04: PUSH2 0x0e0e
00000e07: SWAP3
00000e08: SWAP2
00000e09: SWAP1
00000e0a: PUSH2 0x15b0
00000e0d: JUMP
00000e0e: JUMPDEST
00000e0f: PUSH1 0x20
00000e11: PUSH1 0x40
00000e13: MLOAD
00000e14: DUP1
00000e15: DUP4
00000e16: SUB
00000e17: DUP2
00000e18: PUSH1 0x00
00000e1a: DUP8
00000e1b: DUP1
00000e1c: EXTCODESIZE
00000e1d: ISZERO
00000e1e: DUP1
00000e1f: ISZERO
00000e20: PUSH2 0x0e28
00000e23: JUMPI
00000e24: PUSH1 0x00
00000e26: DUP1
00000e27: REVERT
00000e28: JUMPDEST
00000e29: POP
00000e2a: GAS
00000e2b: CALL
00000e2c: ISZERO
00000e2d: DUP1
00000e2e: ISZERO
00000e2f: PUSH2 0x0e3c
00000e32: JUMPI
00000e33: RETURNDATASIZE
00000e34: PUSH1 0x00
00000e36: DUP1
00000e37: RETURNDATACOPY
00000e38: RETURNDATASIZE
00000e39: PUSH1 0x00
00000e3b: REVERT
00000e3c: JUMPDEST
00000e3d: POP
00000e3e: POP
00000e3f: POP
00000e40: POP
00000e41: PUSH1 0x40
00000e43: MLOAD
00000e44: RETURNDATASIZE
00000e45: PUSH1 0x1f
00000e47: NOT
00000e48: PUSH1 0x1f
00000e4a: DUP3
00000e4b: ADD
00000e4c: AND
00000e4d: DUP3
00000e4e: ADD
00000e4f: DUP1
00000e50: PUSH1 0x40
00000e52: MSTORE
00000e53: POP
00000e54: DUP2
00000e55: ADD
00000e56: SWAP1
00000e57: PUSH2 0x0e60
00000e5a: SWAP2
00000e5b: SWAP1
00000e5c: PUSH2 0x12d2
00000e5f: JUMP
00000e60: JUMPDEST
00000e61: PUSH2 0x0e66
00000e64: JUMPI
00000e65: INVALID
00000e66: JUMPDEST
00000e67: JUMPDEST
00000e68: POP
00000e69: POP
00000e6a: POP
00000e6b: JUMP
00000e6c: JUMPDEST
00000e6d: PUSH1 0x00
00000e6f: PUSH2 0x0e7f
00000e72: PUSH2 0x0e7a
00000e75: DUP5
00000e76: PUSH2 0x16bb
00000e79: JUMP
00000e7a: JUMPDEST
00000e7b: PUSH2 0x168a
00000e7e: JUMP
00000e7f: JUMPDEST
00000e80: SWAP1
00000e81: POP
00000e82: DUP1
00000e83: DUP4
00000e84: DUP3
00000e85: MSTORE
00000e86: PUSH1 0x20
00000e88: DUP3
00000e89: ADD
00000e8a: SWAP1
00000e8b: POP
00000e8c: DUP3
00000e8d: DUP6
00000e8e: PUSH1 0x20
00000e90: DUP7
00000e91: MUL
00000e92: DUP3
00000e93: ADD
00000e94: GT
00000e95: ISZERO
00000e96: PUSH2 0x0e9e
00000e99: JUMPI
00000e9a: PUSH1 0x00
00000e9c: DUP1
00000e9d: REVERT
00000e9e: JUMPDEST
00000e9f: PUSH1 0x00
00000ea1: JUMPDEST
00000ea2: DUP6
00000ea3: DUP2
00000ea4: LT
00000ea5: ISZERO
00000ea6: PUSH2 0x0ece
00000ea9: JUMPI
00000eaa: DUP2
00000eab: PUSH2 0x0eb4
00000eae: DUP9
00000eaf: DUP3
00000eb0: PUSH2 0x101c
00000eb3: JUMP
00000eb4: JUMPDEST
00000eb5: DUP5
00000eb6: MSTORE
00000eb7: PUSH1 0x20
00000eb9: DUP5
00000eba: ADD
00000ebb: SWAP4
00000ebc: POP
00000ebd: PUSH1 0x20
00000ebf: DUP4
00000ec0: ADD
00000ec1: SWAP3
00000ec2: POP
00000ec3: POP
00000ec4: PUSH1 0x01
00000ec6: DUP2
00000ec7: ADD
00000ec8: SWAP1
00000ec9: POP
00000eca: PUSH2 0x0ea1
00000ecd: JUMP
00000ece: JUMPDEST
00000ecf: POP
00000ed0: POP
00000ed1: POP
00000ed2: SWAP4
00000ed3: SWAP3
00000ed4: POP
00000ed5: POP
00000ed6: POP
00000ed7: JUMP
00000ed8: JUMPDEST
00000ed9: PUSH1 0x00
00000edb: PUSH2 0x0eeb
00000ede: PUSH2 0x0ee6
00000ee1: DUP5
00000ee2: PUSH2 0x16e7
00000ee5: JUMP
00000ee6: JUMPDEST
00000ee7: PUSH2 0x168a
00000eea: JUMP
00000eeb: JUMPDEST
00000eec: SWAP1
00000eed: POP
00000eee: DUP1
00000eef: DUP4
00000ef0: DUP3
00000ef1: MSTORE
00000ef2: PUSH1 0x20
00000ef4: DUP3
00000ef5: ADD
00000ef6: SWAP1
00000ef7: POP
00000ef8: DUP3
00000ef9: DUP6
00000efa: PUSH1 0x20
00000efc: DUP7
00000efd: MUL
00000efe: DUP3
00000eff: ADD
00000f00: GT
00000f01: ISZERO
00000f02: PUSH2 0x0f0a
00000f05: JUMPI
00000f06: PUSH1 0x00
00000f08: DUP1
00000f09: REVERT
00000f0a: JUMPDEST
00000f0b: PUSH1 0x00
00000f0d: JUMPDEST
00000f0e: DUP6
00000f0f: DUP2
00000f10: LT
00000f11: ISZERO
00000f12: PUSH2 0x0f3a
00000f15: JUMPI
00000f16: DUP2
00000f17: PUSH2 0x0f20
00000f1a: DUP9
00000f1b: DUP3
00000f1c: PUSH2 0x1118
00000f1f: JUMP
00000f20: JUMPDEST
00000f21: DUP5
00000f22: MSTORE
00000f23: PUSH1 0x20
00000f25: DUP5
00000f26: ADD
00000f27: SWAP4
00000f28: POP
00000f29: PUSH1 0x20
00000f2b: DUP4
00000f2c: ADD
00000f2d: SWAP3
00000f2e: POP
00000f2f: POP
00000f30: PUSH1 0x01
00000f32: DUP2
00000f33: ADD
00000f34: SWAP1
00000f35: POP
00000f36: PUSH2 0x0f0d
00000f39: JUMP
00000f3a: JUMPDEST
00000f3b: POP
00000f3c: POP
00000f3d: POP
00000f3e: SWAP4
00000f3f: SWAP3
00000f40: POP
00000f41: POP
00000f42: POP
00000f43: JUMP
00000f44: JUMPDEST
00000f45: PUSH1 0x00
00000f47: PUSH2 0x0f57
00000f4a: PUSH2 0x0f52
00000f4d: DUP5
00000f4e: PUSH2 0x1713
00000f51: JUMP
00000f52: JUMPDEST
00000f53: PUSH2 0x168a
00000f56: JUMP
00000f57: JUMPDEST
00000f58: SWAP1
00000f59: POP
00000f5a: DUP1
00000f5b: DUP4
00000f5c: DUP3
00000f5d: MSTORE
00000f5e: PUSH1 0x20
00000f60: DUP3
00000f61: ADD
00000f62: SWAP1
00000f63: POP
00000f64: DUP3
00000f65: DUP6
00000f66: PUSH1 0x20
00000f68: DUP7
00000f69: MUL
00000f6a: DUP3
00000f6b: ADD
00000f6c: GT
00000f6d: ISZERO
00000f6e: PUSH2 0x0f76
00000f71: JUMPI
00000f72: PUSH1 0x00
00000f74: DUP1
00000f75: REVERT
00000f76: JUMPDEST
00000f77: PUSH1 0x00
00000f79: JUMPDEST
00000f7a: DUP6
00000f7b: DUP2
00000f7c: LT
00000f7d: ISZERO
00000f7e: PUSH2 0x0fa6
00000f81: JUMPI
00000f82: DUP2
00000f83: PUSH2 0x0f8c
00000f86: DUP9
00000f87: DUP3
00000f88: PUSH2 0x112d
00000f8b: JUMP
00000f8c: JUMPDEST
00000f8d: DUP5
00000f8e: MSTORE
00000f8f: PUSH1 0x20
00000f91: DUP5
00000f92: ADD
00000f93: SWAP4
00000f94: POP
00000f95: PUSH1 0x20
00000f97: DUP4
00000f98: ADD
00000f99: SWAP3
00000f9a: POP
00000f9b: POP
00000f9c: PUSH1 0x01
00000f9e: DUP2
00000f9f: ADD
00000fa0: SWAP1
00000fa1: POP
00000fa2: PUSH2 0x0f79
00000fa5: JUMP
00000fa6: JUMPDEST
00000fa7: POP
00000fa8: POP
00000fa9: POP
00000faa: SWAP4
00000fab: SWAP3
00000fac: POP
00000fad: POP
00000fae: POP
00000faf: JUMP
00000fb0: JUMPDEST
00000fb1: PUSH1 0x00
00000fb3: PUSH2 0x0fc3
00000fb6: PUSH2 0x0fbe
00000fb9: DUP5
00000fba: PUSH2 0x1713
00000fbd: JUMP
00000fbe: JUMPDEST
00000fbf: PUSH2 0x168a
00000fc2: JUMP
00000fc3: JUMPDEST
00000fc4: SWAP1
00000fc5: POP
00000fc6: DUP1
00000fc7: DUP4
00000fc8: DUP3
00000fc9: MSTORE
00000fca: PUSH1 0x20
00000fcc: DUP3
00000fcd: ADD
00000fce: SWAP1
00000fcf: POP
00000fd0: DUP3
00000fd1: DUP6
00000fd2: PUSH1 0x20
00000fd4: DUP7
00000fd5: MUL
00000fd6: DUP3
00000fd7: ADD
00000fd8: GT
00000fd9: ISZERO
00000fda: PUSH2 0x0fe2
00000fdd: JUMPI
00000fde: PUSH1 0x00
00000fe0: DUP1
00000fe1: REVERT
00000fe2: JUMPDEST
00000fe3: PUSH1 0x00
00000fe5: JUMPDEST
00000fe6: DUP6
00000fe7: DUP2
00000fe8: LT
00000fe9: ISZERO
00000fea: PUSH2 0x1012
00000fed: JUMPI
00000fee: DUP2
00000fef: PUSH2 0x0ff8
00000ff2: DUP9
00000ff3: DUP3
00000ff4: PUSH2 0x1142
00000ff7: JUMP
00000ff8: JUMPDEST
00000ff9: DUP5
00000ffa: MSTORE
00000ffb: PUSH1 0x20
00000ffd: DUP5
00000ffe: ADD
00000fff: SWAP4
00001000: POP
00001001: PUSH1 0x20
00001003: DUP4
00001004: ADD
00001005: SWAP3
00001006: POP
00001007: POP
00001008: PUSH1 0x01
0000100a: DUP2
0000100b: ADD
0000100c: SWAP1
0000100d: POP
0000100e: PUSH2 0x0fe5
00001011: JUMP
00001012: JUMPDEST
00001013: POP
00001014: POP
00001015: POP
00001016: SWAP4
00001017: SWAP3
00001018: POP
00001019: POP
0000101a: POP
0000101b: JUMP
0000101c: JUMPDEST
0000101d: PUSH1 0x00
0000101f: DUP2
00001020: CALLDATALOAD
00001021: SWAP1
00001022: POP
00001023: PUSH2 0x102b
00001026: DUP2
00001027: PUSH2 0x183c
0000102a: JUMP
0000102b: JUMPDEST
0000102c: SWAP3
0000102d: SWAP2
0000102e: POP
0000102f: POP
00001030: JUMP
00001031: JUMPDEST
00001032: PUSH1 0x00
00001034: DUP3
00001035: PUSH1 0x1f
00001037: DUP4
00001038: ADD
00001039: SLT
0000103a: PUSH2 0x1042
0000103d: JUMPI
0000103e: PUSH1 0x00
00001040: DUP1
00001041: REVERT
00001042: JUMPDEST
00001043: DUP2
00001044: CALLDATALOAD
00001045: PUSH2 0x1052
00001048: DUP5
00001049: DUP3
0000104a: PUSH1 0x20
0000104c: DUP7
0000104d: ADD
0000104e: PUSH2 0x0e6c
00001051: JUMP
00001052: JUMPDEST
00001053: SWAP2
00001054: POP
00001055: POP
00001056: SWAP3
00001057: SWAP2
00001058: POP
00001059: POP
0000105a: JUMP
0000105b: JUMPDEST
0000105c: PUSH1 0x00
0000105e: DUP3
0000105f: PUSH1 0x1f
00001061: DUP4
00001062: ADD
00001063: SLT
00001064: PUSH2 0x106c
00001067: JUMPI
00001068: PUSH1 0x00
0000106a: DUP1
0000106b: REVERT
0000106c: JUMPDEST
0000106d: DUP2
0000106e: CALLDATALOAD
0000106f: PUSH2 0x107c
00001072: DUP5
00001073: DUP3
00001074: PUSH1 0x20
00001076: DUP7
00001077: ADD
00001078: PUSH2 0x0ed8
0000107b: JUMP
0000107c: JUMPDEST
0000107d: SWAP2
0000107e: POP
0000107f: POP
00001080: SWAP3
00001081: SWAP2
00001082: POP
00001083: POP
00001084: JUMP
00001085: JUMPDEST
00001086: PUSH1 0x00
00001088: DUP3
00001089: PUSH1 0x1f
0000108b: DUP4
0000108c: ADD
0000108d: SLT
0000108e: PUSH2 0x1096
00001091: JUMPI
00001092: PUSH1 0x00
00001094: DUP1
00001095: REVERT
00001096: JUMPDEST
00001097: DUP2
00001098: CALLDATALOAD
00001099: PUSH2 0x10a6
0000109c: DUP5
0000109d: DUP3
0000109e: PUSH1 0x20
000010a0: DUP7
000010a1: ADD
000010a2: PUSH2 0x0f44
000010a5: JUMP
000010a6: JUMPDEST
000010a7: SWAP2
000010a8: POP
000010a9: POP
000010aa: SWAP3
000010ab: SWAP2
000010ac: POP
000010ad: POP
000010ae: JUMP
000010af: JUMPDEST
000010b0: PUSH1 0x00
000010b2: DUP3
000010b3: PUSH1 0x1f
000010b5: DUP4
000010b6: ADD
000010b7: SLT
000010b8: PUSH2 0x10c0
000010bb: JUMPI
000010bc: PUSH1 0x00
000010be: DUP1
000010bf: REVERT
000010c0: JUMPDEST
000010c1: DUP2
000010c2: MLOAD
000010c3: PUSH2 0x10d0
000010c6: DUP5
000010c7: DUP3
000010c8: PUSH1 0x20
000010ca: DUP7
000010cb: ADD
000010cc: PUSH2 0x0fb0
000010cf: JUMP
000010d0: JUMPDEST
000010d1: SWAP2
000010d2: POP
000010d3: POP
000010d4: SWAP3
000010d5: SWAP2
000010d6: POP
000010d7: POP
000010d8: JUMP
000010d9: JUMPDEST
000010da: PUSH1 0x00
000010dc: DUP2
000010dd: CALLDATALOAD
000010de: SWAP1
000010df: POP
000010e0: PUSH2 0x10e8
000010e3: DUP2
000010e4: PUSH2 0x1853
000010e7: JUMP
000010e8: JUMPDEST
000010e9: SWAP3
000010ea: SWAP2
000010eb: POP
000010ec: POP
000010ed: JUMP
000010ee: JUMPDEST
000010ef: PUSH1 0x00
000010f1: DUP2
000010f2: MLOAD
000010f3: SWAP1
000010f4: POP
000010f5: PUSH2 0x10fd
000010f8: DUP2
000010f9: PUSH2 0x1853
000010fc: JUMP
000010fd: JUMPDEST
000010fe: SWAP3
000010ff: SWAP2
00001100: POP
00001101: POP
00001102: JUMP
00001103: JUMPDEST
00001104: PUSH1 0x00
00001106: DUP2
00001107: CALLDATALOAD
00001108: SWAP1
00001109: POP
0000110a: PUSH2 0x1112
0000110d: DUP2
0000110e: PUSH2 0x186a
00001111: JUMP
00001112: JUMPDEST
00001113: SWAP3
00001114: SWAP2
00001115: POP
00001116: POP
00001117: JUMP
00001118: JUMPDEST
00001119: PUSH1 0x00
0000111b: DUP2
0000111c: CALLDATALOAD
0000111d: SWAP1
0000111e: POP
0000111f: PUSH2 0x1127
00001122: DUP2
00001123: PUSH2 0x1881
00001126: JUMP
00001127: JUMPDEST
00001128: SWAP3
00001129: SWAP2
0000112a: POP
0000112b: POP
0000112c: JUMP
0000112d: JUMPDEST
0000112e: PUSH1 0x00
00001130: DUP2
00001131: CALLDATALOAD
00001132: SWAP1
00001133: POP
00001134: PUSH2 0x113c
00001137: DUP2
00001138: PUSH2 0x1898
0000113b: JUMP
0000113c: JUMPDEST
0000113d: SWAP3
0000113e: SWAP2
0000113f: POP
00001140: POP
00001141: JUMP
00001142: JUMPDEST
00001143: PUSH1 0x00
00001145: DUP2
00001146: MLOAD
00001147: SWAP1
00001148: POP
00001149: PUSH2 0x1151
0000114c: DUP2
0000114d: PUSH2 0x1898
00001150: JUMP
00001151: JUMPDEST
00001152: SWAP3
00001153: SWAP2
00001154: POP
00001155: POP
00001156: JUMP
00001157: JUMPDEST
00001158: PUSH1 0x00
0000115a: DUP1
0000115b: PUSH1 0x40
0000115d: DUP4
0000115e: DUP6
0000115f: SUB
00001160: SLT
00001161: ISZERO
00001162: PUSH2 0x116a
00001165: JUMPI
00001166: PUSH1 0x00
00001168: DUP1
00001169: REVERT
0000116a: JUMPDEST
0000116b: PUSH1 0x00
0000116d: PUSH2 0x1178
00001170: DUP6
00001171: DUP3
00001172: DUP7
00001173: ADD
00001174: PUSH2 0x101c
00001177: JUMP
00001178: JUMPDEST
00001179: SWAP3
0000117a: POP
0000117b: POP
0000117c: PUSH1 0x20
0000117e: PUSH2 0x1189
00001181: DUP6
00001182: DUP3
00001183: DUP7
00001184: ADD
00001185: PUSH2 0x10d9
00001188: JUMP
00001189: JUMPDEST
0000118a: SWAP2
0000118b: POP
0000118c: POP
0000118d: SWAP3
0000118e: POP
0000118f: SWAP3
00001190: SWAP1
00001191: POP
00001192: JUMP
00001193: JUMPDEST
00001194: PUSH1 0x00
00001196: PUSH1 0x20
00001198: DUP3
00001199: DUP5
0000119a: SUB
0000119b: SLT
0000119c: ISZERO
0000119d: PUSH2 0x11a5
000011a0: JUMPI
000011a1: PUSH1 0x00
000011a3: DUP1
000011a4: REVERT
000011a5: JUMPDEST
000011a6: PUSH1 0x00
000011a8: DUP3
000011a9: ADD
000011aa: MLOAD
000011ab: PUSH8 0xffffffffffffffff
000011b4: DUP2
000011b5: GT
000011b6: ISZERO
000011b7: PUSH2 0x11bf
000011ba: JUMPI
000011bb: PUSH1 0x00
000011bd: DUP1
000011be: REVERT
000011bf: JUMPDEST
000011c0: PUSH2 0x11cb
000011c3: DUP5
000011c4: DUP3
000011c5: DUP6
000011c6: ADD
000011c7: PUSH2 0x10af
000011ca: JUMP
000011cb: JUMPDEST
000011cc: SWAP2
000011cd: POP
000011ce: POP
000011cf: SWAP3
000011d0: SWAP2
000011d1: POP
000011d2: POP
000011d3: JUMP
000011d4: JUMPDEST
000011d5: PUSH1 0x00
000011d7: DUP1
000011d8: PUSH1 0x00
000011da: DUP1
000011db: PUSH1 0x00
000011dd: DUP1
000011de: PUSH1 0x00
000011e0: PUSH1 0xe0
000011e2: DUP9
000011e3: DUP11
000011e4: SUB
000011e5: SLT
000011e6: ISZERO
000011e7: PUSH2 0x11ef
000011ea: JUMPI
000011eb: PUSH1 0x00
000011ed: DUP1
000011ee: REVERT
000011ef: JUMPDEST
000011f0: PUSH1 0x00
000011f2: DUP9
000011f3: ADD
000011f4: CALLDATALOAD
000011f5: PUSH8 0xffffffffffffffff
000011fe: DUP2
000011ff: GT
00001200: ISZERO
00001201: PUSH2 0x1209
00001204: JUMPI
00001205: PUSH1 0x00
00001207: DUP1
00001208: REVERT
00001209: JUMPDEST
0000120a: PUSH2 0x1215
0000120d: DUP11
0000120e: DUP3
0000120f: DUP12
00001210: ADD
00001211: PUSH2 0x1085
00001214: JUMP
00001215: JUMPDEST
00001216: SWAP8
00001217: POP
00001218: POP
00001219: PUSH1 0x20
0000121b: DUP9
0000121c: ADD
0000121d: CALLDATALOAD
0000121e: PUSH8 0xffffffffffffffff
00001227: DUP2
00001228: GT
00001229: ISZERO
0000122a: PUSH2 0x1232
0000122d: JUMPI
0000122e: PUSH1 0x00
00001230: DUP1
00001231: REVERT
00001232: JUMPDEST
00001233: PUSH2 0x123e
00001236: DUP11
00001237: DUP3
00001238: DUP12
00001239: ADD
0000123a: PUSH2 0x1031
0000123d: JUMP
0000123e: JUMPDEST
0000123f: SWAP7
00001240: POP
00001241: POP
00001242: PUSH1 0x40
00001244: DUP9
00001245: ADD
00001246: CALLDATALOAD
00001247: PUSH8 0xffffffffffffffff
00001250: DUP2
00001251: GT
00001252: ISZERO
00001253: PUSH2 0x125b
00001256: JUMPI
00001257: PUSH1 0x00
00001259: DUP1
0000125a: REVERT
0000125b: JUMPDEST
0000125c: PUSH2 0x1267
0000125f: DUP11
00001260: DUP3
00001261: DUP12
00001262: ADD
00001263: PUSH2 0x1031
00001266: JUMP
00001267: JUMPDEST
00001268: SWAP6
00001269: POP
0000126a: POP
0000126b: PUSH1 0x60
0000126d: DUP9
0000126e: ADD
0000126f: CALLDATALOAD
00001270: PUSH8 0xffffffffffffffff
00001279: DUP2
0000127a: GT
0000127b: ISZERO
0000127c: PUSH2 0x1284
0000127f: JUMPI
00001280: PUSH1 0x00
00001282: DUP1
00001283: REVERT
00001284: JUMPDEST
00001285: PUSH2 0x1290
00001288: DUP11
00001289: DUP3
0000128a: DUP12
0000128b: ADD
0000128c: PUSH2 0x105b
0000128f: JUMP
00001290: JUMPDEST
00001291: SWAP5
00001292: POP
00001293: POP
00001294: PUSH1 0x80
00001296: PUSH2 0x12a1
00001299: DUP11
0000129a: DUP3
0000129b: DUP12
0000129c: ADD
0000129d: PUSH2 0x112d
000012a0: JUMP
000012a1: JUMPDEST
000012a2: SWAP4
000012a3: POP
000012a4: POP
000012a5: PUSH1 0xa0
000012a7: PUSH2 0x12b2
000012aa: DUP11
000012ab: DUP3
000012ac: DUP12
000012ad: ADD
000012ae: PUSH2 0x112d
000012b1: JUMP
000012b2: JUMPDEST
000012b3: SWAP3
000012b4: POP
000012b5: POP
000012b6: PUSH1 0xc0
000012b8: PUSH2 0x12c3
000012bb: DUP11
000012bc: DUP3
000012bd: DUP12
000012be: ADD
000012bf: PUSH2 0x112d
000012c2: JUMP
000012c3: JUMPDEST
000012c4: SWAP2
000012c5: POP
000012c6: POP
000012c7: SWAP3
000012c8: SWAP6
000012c9: SWAP9
000012ca: SWAP2
000012cb: SWAP5
000012cc: SWAP8
000012cd: POP
000012ce: SWAP3
000012cf: SWAP6
000012d0: POP
000012d1: JUMP
000012d2: JUMPDEST
000012d3: PUSH1 0x00
000012d5: PUSH1 0x20
000012d7: DUP3
000012d8: DUP5
000012d9: SUB
000012da: SLT
000012db: ISZERO
000012dc: PUSH2 0x12e4
000012df: JUMPI
000012e0: PUSH1 0x00
000012e2: DUP1
000012e3: REVERT
000012e4: JUMPDEST
000012e5: PUSH1 0x00
000012e7: PUSH2 0x12f2
000012ea: DUP5
000012eb: DUP3
000012ec: DUP6
000012ed: ADD
000012ee: PUSH2 0x10ee
000012f1: JUMP
000012f2: JUMPDEST
000012f3: SWAP2
000012f4: POP
000012f5: POP
000012f6: SWAP3
000012f7: SWAP2
000012f8: POP
000012f9: POP
000012fa: JUMP
000012fb: JUMPDEST
000012fc: PUSH1 0x00
000012fe: DUP1
000012ff: PUSH1 0x00
00001301: PUSH1 0x60
00001303: DUP5
00001304: DUP7
00001305: SUB
00001306: SLT
00001307: ISZERO
00001308: PUSH2 0x1310
0000130b: JUMPI
0000130c: PUSH1 0x00
0000130e: DUP1
0000130f: REVERT
00001310: JUMPDEST
00001311: PUSH1 0x00
00001313: PUSH2 0x131e
00001316: DUP7
00001317: DUP3
00001318: DUP8
00001319: ADD
0000131a: PUSH2 0x1103
0000131d: JUMP
0000131e: JUMPDEST
0000131f: SWAP4
00001320: POP
00001321: POP
00001322: PUSH1 0x20
00001324: PUSH2 0x132f
00001327: DUP7
00001328: DUP3
00001329: DUP8
0000132a: ADD
0000132b: PUSH2 0x101c
0000132e: JUMP
0000132f: JUMPDEST
00001330: SWAP3
00001331: POP
00001332: POP
00001333: PUSH1 0x40
00001335: PUSH2 0x1340
00001338: DUP7
00001339: DUP3
0000133a: DUP8
0000133b: ADD
0000133c: PUSH2 0x112d
0000133f: JUMP
00001340: JUMPDEST
00001341: SWAP2
00001342: POP
00001343: POP
00001344: SWAP3
00001345: POP
00001346: SWAP3
00001347: POP
00001348: SWAP3
00001349: JUMP
0000134a: JUMPDEST
0000134b: PUSH1 0x00
0000134d: PUSH1 0x20
0000134f: DUP3
00001350: DUP5
00001351: SUB
00001352: SLT
00001353: ISZERO
00001354: PUSH2 0x135c
00001357: JUMPI
00001358: PUSH1 0x00
0000135a: DUP1
0000135b: REVERT
0000135c: JUMPDEST
0000135d: PUSH1 0x00
0000135f: PUSH2 0x136a
00001362: DUP5
00001363: DUP3
00001364: DUP6
00001365: ADD
00001366: PUSH2 0x112d
00001369: JUMP
0000136a: JUMPDEST
0000136b: SWAP2
0000136c: POP
0000136d: POP
0000136e: SWAP3
0000136f: SWAP2
00001370: POP
00001371: POP
00001372: JUMP
00001373: JUMPDEST
00001374: PUSH1 0x00
00001376: PUSH1 0x20
00001378: DUP3
00001379: DUP5
0000137a: SUB
0000137b: SLT
0000137c: ISZERO
0000137d: PUSH2 0x1385
00001380: JUMPI
00001381: PUSH1 0x00
00001383: DUP1
00001384: REVERT
00001385: JUMPDEST
00001386: PUSH1 0x00
00001388: PUSH2 0x1393
0000138b: DUP5
0000138c: DUP3
0000138d: DUP6
0000138e: ADD
0000138f: PUSH2 0x1142
00001392: JUMP
00001393: JUMPDEST
00001394: SWAP2
00001395: POP
00001396: POP
00001397: SWAP3
00001398: SWAP2
00001399: POP
0000139a: POP
0000139b: JUMP
0000139c: JUMPDEST
0000139d: PUSH1 0x00
0000139f: PUSH2 0x13a8
000013a2: DUP4
000013a3: DUP4
000013a4: PUSH2 0x13d2
000013a7: JUMP
000013a8: JUMPDEST
000013a9: PUSH1 0x20
000013ab: DUP4
000013ac: ADD
000013ad: SWAP1
000013ae: POP
000013af: SWAP3
000013b0: SWAP2
000013b1: POP
000013b2: POP
000013b3: JUMP
000013b4: JUMPDEST
000013b5: PUSH2 0x13bd
000013b8: DUP2
000013b9: PUSH2 0x1804
000013bc: JUMP
000013bd: JUMPDEST
000013be: DUP3
000013bf: MSTORE
000013c0: POP
000013c1: POP
000013c2: JUMP
000013c3: JUMPDEST
000013c4: PUSH2 0x13cc
000013c7: DUP2
000013c8: PUSH2 0x179b
000013cb: JUMP
000013cc: JUMPDEST
000013cd: DUP3
000013ce: MSTORE
000013cf: POP
000013d0: POP
000013d1: JUMP
000013d2: JUMPDEST
000013d3: PUSH2 0x13db
000013d6: DUP2
000013d7: PUSH2 0x1789
000013da: JUMP
000013db: JUMPDEST
000013dc: DUP3
000013dd: MSTORE
000013de: POP
000013df: POP
000013e0: JUMP
000013e1: JUMPDEST
000013e2: PUSH2 0x13ea
000013e5: DUP2
000013e6: PUSH2 0x1789
000013e9: JUMP
000013ea: JUMPDEST
000013eb: DUP3
000013ec: MSTORE
000013ed: POP
000013ee: POP
000013ef: JUMP
000013f0: JUMPDEST
000013f1: PUSH1 0x00
000013f3: PUSH2 0x13fb
000013f6: DUP3
000013f7: PUSH2 0x174f
000013fa: JUMP
000013fb: JUMPDEST
000013fc: PUSH2 0x1405
000013ff: DUP2
00001400: DUP6
00001401: PUSH2 0x1767
00001404: JUMP
00001405: JUMPDEST
00001406: SWAP4
00001407: POP
00001408: PUSH2 0x1410
0000140b: DUP4
0000140c: PUSH2 0x173f
0000140f: JUMP
00001410: JUMPDEST
00001411: DUP1
00001412: PUSH1 0x00
00001414: JUMPDEST
00001415: DUP4
00001416: DUP2
00001417: LT
00001418: ISZERO
00001419: PUSH2 0x1441
0000141c: JUMPI
0000141d: DUP2
0000141e: MLOAD
0000141f: PUSH2 0x1428
00001422: DUP9
00001423: DUP3
00001424: PUSH2 0x139c
00001427: JUMP
00001428: JUMPDEST
00001429: SWAP8
0000142a: POP
0000142b: PUSH2 0x1433
0000142e: DUP4
0000142f: PUSH2 0x175a
00001432: JUMP
00001433: JUMPDEST
00001434: SWAP3
00001435: POP
00001436: POP
00001437: PUSH1 0x01
00001439: DUP2
0000143a: ADD
0000143b: SWAP1
0000143c: POP
0000143d: PUSH2 0x1414
00001440: JUMP
00001441: JUMPDEST
00001442: POP
00001443: DUP6
00001444: SWAP4
00001445: POP
00001446: POP
00001447: POP
00001448: POP
00001449: SWAP3
0000144a: SWAP2
0000144b: POP
0000144c: POP
0000144d: JUMP
0000144e: JUMPDEST
0000144f: PUSH1 0x00
00001451: PUSH2 0x145b
00001454: PUSH1 0x0e
00001456: DUP4
00001457: PUSH2 0x1778
0000145a: JUMP
0000145b: JUMPDEST
0000145c: SWAP2
0000145d: POP
0000145e: PUSH32 0x63616e43616c6c41646472657373000000000000000000000000000000000000
0000147f: PUSH1 0x00
00001481: DUP4
00001482: ADD
00001483: MSTORE
00001484: PUSH1 0x20
00001486: DUP3
00001487: ADD
00001488: SWAP1
00001489: POP
0000148a: SWAP2
0000148b: SWAP1
0000148c: POP
0000148d: JUMP
0000148e: JUMPDEST
0000148f: PUSH2 0x0100
00001492: DUP3
00001493: ADD
00001494: PUSH1 0x00
00001496: DUP3
00001497: ADD
00001498: MLOAD
00001499: PUSH2 0x14a5
0000149c: PUSH1 0x00
0000149e: DUP6
0000149f: ADD
000014a0: DUP3
000014a1: PUSH2 0x13d2
000014a4: JUMP
000014a5: JUMPDEST
000014a6: POP
000014a7: PUSH1 0x20
000014a9: DUP3
000014aa: ADD
000014ab: MLOAD
000014ac: PUSH2 0x14b8
000014af: PUSH1 0x20
000014b1: DUP6
000014b2: ADD
000014b3: DUP3
000014b4: PUSH2 0x13d2
000014b7: JUMP
000014b8: JUMPDEST
000014b9: POP
000014ba: PUSH1 0x40
000014bc: DUP3
000014bd: ADD
000014be: MLOAD
000014bf: PUSH2 0x14cb
000014c2: PUSH1 0x40
000014c4: DUP6
000014c5: ADD
000014c6: DUP3
000014c7: PUSH2 0x153f
000014ca: JUMP
000014cb: JUMPDEST
000014cc: POP
000014cd: PUSH1 0x60
000014cf: DUP3
000014d0: ADD
000014d1: MLOAD
000014d2: PUSH2 0x14de
000014d5: PUSH1 0x60
000014d7: DUP6
000014d8: ADD
000014d9: DUP3
000014da: PUSH2 0x13d2
000014dd: JUMP
000014de: JUMPDEST
000014df: POP
000014e0: PUSH1 0x80
000014e2: DUP3
000014e3: ADD
000014e4: MLOAD
000014e5: PUSH2 0x14f1
000014e8: PUSH1 0x80
000014ea: DUP6
000014eb: ADD
000014ec: DUP3
000014ed: PUSH2 0x154e
000014f0: JUMP
000014f1: JUMPDEST
000014f2: POP
000014f3: PUSH1 0xa0
000014f5: DUP3
000014f6: ADD
000014f7: MLOAD
000014f8: PUSH2 0x1504
000014fb: PUSH1 0xa0
000014fd: DUP6
000014fe: ADD
000014ff: DUP3
00001500: PUSH2 0x154e
00001503: JUMP
00001504: JUMPDEST
00001505: POP
00001506: PUSH1 0xc0
00001508: DUP3
00001509: ADD
0000150a: MLOAD
0000150b: PUSH2 0x1517
0000150e: PUSH1 0xc0
00001510: DUP6
00001511: ADD
00001512: DUP3
00001513: PUSH2 0x154e
00001516: JUMP
00001517: JUMPDEST
00001518: POP
00001519: PUSH1 0xe0
0000151b: DUP3
0000151c: ADD
0000151d: MLOAD
0000151e: PUSH2 0x152a
00001521: PUSH1 0xe0
00001523: DUP6
00001524: ADD
00001525: DUP3
00001526: PUSH2 0x1530
00001529: JUMP
0000152a: JUMPDEST
0000152b: POP
0000152c: POP
0000152d: POP
0000152e: POP
0000152f: JUMP
00001530: JUMPDEST
00001531: PUSH2 0x1539
00001534: DUP2
00001535: PUSH2 0x17cb
00001538: JUMP
00001539: JUMPDEST
0000153a: DUP3
0000153b: MSTORE
0000153c: POP
0000153d: POP
0000153e: JUMP
0000153f: JUMPDEST
00001540: PUSH2 0x1548
00001543: DUP2
00001544: PUSH2 0x17eb
00001547: JUMP
00001548: JUMPDEST
00001549: DUP3
0000154a: MSTORE
0000154b: POP
0000154c: POP
0000154d: JUMP
0000154e: JUMPDEST
0000154f: PUSH2 0x1557
00001552: DUP2
00001553: PUSH2 0x17fa
00001556: JUMP
00001557: JUMPDEST
00001558: DUP3
00001559: MSTORE
0000155a: POP
0000155b: POP
0000155c: JUMP
0000155d: JUMPDEST
0000155e: PUSH2 0x1566
00001561: DUP2
00001562: PUSH2 0x17fa
00001565: JUMP
00001566: JUMPDEST
00001567: DUP3
00001568: MSTORE
00001569: POP
0000156a: POP
0000156b: JUMP
0000156c: JUMPDEST
0000156d: PUSH1 0x00
0000156f: PUSH1 0x20
00001571: DUP3
00001572: ADD
00001573: SWAP1
00001574: POP
00001575: PUSH2 0x1581
00001578: PUSH1 0x00
0000157a: DUP4
0000157b: ADD
0000157c: DUP5
0000157d: PUSH2 0x13c3
00001580: JUMP
00001581: JUMPDEST
00001582: SWAP3
00001583: SWAP2
00001584: POP
00001585: POP
00001586: JUMP
00001587: JUMPDEST
00001588: PUSH1 0x00
0000158a: PUSH1 0x40
0000158c: DUP3
0000158d: ADD
0000158e: SWAP1
0000158f: POP
00001590: PUSH2 0x159c
00001593: PUSH1 0x00
00001595: DUP4
00001596: ADD
00001597: DUP6
00001598: PUSH2 0x13b4
0000159b: JUMP
0000159c: JUMPDEST
0000159d: PUSH2 0x15a9
000015a0: PUSH1 0x20
000015a2: DUP4
000015a3: ADD
000015a4: DUP5
000015a5: PUSH2 0x13e1
000015a8: JUMP
000015a9: JUMPDEST
000015aa: SWAP4
000015ab: SWAP3
000015ac: POP
000015ad: POP
000015ae: POP
000015af: JUMP
000015b0: JUMPDEST
000015b1: PUSH1 0x00
000015b3: PUSH1 0x40
000015b5: DUP3
000015b6: ADD
000015b7: SWAP1
000015b8: POP
000015b9: PUSH2 0x15c5
000015bc: PUSH1 0x00
000015be: DUP4
000015bf: ADD
000015c0: DUP6
000015c1: PUSH2 0x13e1
000015c4: JUMP
000015c5: JUMPDEST
000015c6: PUSH2 0x15d2
000015c9: PUSH1 0x20
000015cb: DUP4
000015cc: ADD
000015cd: DUP5
000015ce: PUSH2 0x155d
000015d1: JUMP
000015d2: JUMPDEST
000015d3: SWAP4
000015d4: SWAP3
000015d5: POP
000015d6: POP
000015d7: POP
000015d8: JUMP
000015d9: JUMPDEST
000015da: PUSH1 0x00
000015dc: PUSH1 0x20
000015de: DUP3
000015df: ADD
000015e0: SWAP1
000015e1: POP
000015e2: DUP2
000015e3: DUP2
000015e4: SUB
000015e5: PUSH1 0x00
000015e7: DUP4
000015e8: ADD
000015e9: MSTORE
000015ea: PUSH2 0x15f2
000015ed: DUP2
000015ee: PUSH2 0x144e
000015f1: JUMP
000015f2: JUMPDEST
000015f3: SWAP1
000015f4: POP
000015f5: SWAP2
000015f6: SWAP1
000015f7: POP
000015f8: JUMP
000015f9: JUMPDEST
000015fa: PUSH1 0x00
000015fc: PUSH2 0x0100
000015ff: DUP3
00001600: ADD
00001601: SWAP1
00001602: POP
00001603: PUSH2 0x160f
00001606: PUSH1 0x00
00001608: DUP4
00001609: ADD
0000160a: DUP5
0000160b: PUSH2 0x148e
0000160e: JUMP
0000160f: JUMPDEST
00001610: SWAP3
00001611: SWAP2
00001612: POP
00001613: POP
00001614: JUMP
00001615: JUMPDEST
00001616: PUSH1 0x00
00001618: PUSH1 0x20
0000161a: DUP3
0000161b: ADD
0000161c: SWAP1
0000161d: POP
0000161e: PUSH2 0x162a
00001621: PUSH1 0x00
00001623: DUP4
00001624: ADD
00001625: DUP5
00001626: PUSH2 0x155d
00001629: JUMP
0000162a: JUMPDEST
0000162b: SWAP3
0000162c: SWAP2
0000162d: POP
0000162e: POP
0000162f: JUMP
00001630: JUMPDEST
00001631: PUSH1 0x00
00001633: PUSH1 0xa0
00001635: DUP3
00001636: ADD
00001637: SWAP1
00001638: POP
00001639: PUSH2 0x1645
0000163c: PUSH1 0x00
0000163e: DUP4
0000163f: ADD
00001640: DUP9
00001641: PUSH2 0x155d
00001644: JUMP
00001645: JUMPDEST
00001646: PUSH2 0x1652
00001649: PUSH1 0x20
0000164b: DUP4
0000164c: ADD
0000164d: DUP8
0000164e: PUSH2 0x155d
00001651: JUMP
00001652: JUMPDEST
00001653: DUP2
00001654: DUP2
00001655: SUB
00001656: PUSH1 0x40
00001658: DUP4
00001659: ADD
0000165a: MSTORE
0000165b: PUSH2 0x1664
0000165e: DUP2
0000165f: DUP7
00001660: PUSH2 0x13f0
00001663: JUMP
00001664: JUMPDEST
00001665: SWAP1
00001666: POP
00001667: PUSH2 0x1673
0000166a: PUSH1 0x60
0000166c: DUP4
0000166d: ADD
0000166e: DUP6
0000166f: PUSH2 0x13e1
00001672: JUMP
00001673: JUMPDEST
00001674: PUSH2 0x1680
00001677: PUSH1 0x80
00001679: DUP4
0000167a: ADD
0000167b: DUP5
0000167c: PUSH2 0x155d
0000167f: JUMP
00001680: JUMPDEST
00001681: SWAP7
00001682: SWAP6
00001683: POP
00001684: POP
00001685: POP
00001686: POP
00001687: POP
00001688: POP
00001689: JUMP
0000168a: JUMPDEST
0000168b: PUSH1 0x00
0000168d: PUSH1 0x40
0000168f: MLOAD
00001690: SWAP1
00001691: POP
00001692: DUP2
00001693: DUP2
00001694: ADD
00001695: DUP2
00001696: DUP2
00001697: LT
00001698: PUSH8 0xffffffffffffffff
000016a1: DUP3
000016a2: GT
000016a3: OR
000016a4: ISZERO
000016a5: PUSH2 0x16b1
000016a8: JUMPI
000016a9: PUSH2 0x16b0
000016ac: PUSH2 0x183a
000016af: JUMP
000016b0: JUMPDEST
000016b1: JUMPDEST
000016b2: DUP1
000016b3: PUSH1 0x40
000016b5: MSTORE
000016b6: POP
000016b7: SWAP2
000016b8: SWAP1
000016b9: POP
000016ba: JUMP
000016bb: JUMPDEST
000016bc: PUSH1 0x00
000016be: PUSH8 0xffffffffffffffff
000016c7: DUP3
000016c8: GT
000016c9: ISZERO
000016ca: PUSH2 0x16d6
000016cd: JUMPI
000016ce: PUSH2 0x16d5
000016d1: PUSH2 0x183a
000016d4: JUMP
000016d5: JUMPDEST
000016d6: JUMPDEST
000016d7: PUSH1 0x20
000016d9: DUP3
000016da: MUL
000016db: SWAP1
000016dc: POP
000016dd: PUSH1 0x20
000016df: DUP2
000016e0: ADD
000016e1: SWAP1
000016e2: POP
000016e3: SWAP2
000016e4: SWAP1
000016e5: POP
000016e6: JUMP
000016e7: JUMPDEST
000016e8: PUSH1 0x00
000016ea: PUSH8 0xffffffffffffffff
000016f3: DUP3
000016f4: GT
000016f5: ISZERO
000016f6: PUSH2 0x1702
000016f9: JUMPI
000016fa: PUSH2 0x1701
000016fd: PUSH2 0x183a
00001700: JUMP
00001701: JUMPDEST
00001702: JUMPDEST
00001703: PUSH1 0x20
00001705: DUP3
00001706: MUL
00001707: SWAP1
00001708: POP
00001709: PUSH1 0x20
0000170b: DUP2
0000170c: ADD
0000170d: SWAP1
0000170e: POP
0000170f: SWAP2
00001710: SWAP1
00001711: POP
00001712: JUMP
00001713: JUMPDEST
00001714: PUSH1 0x00
00001716: PUSH8 0xffffffffffffffff
0000171f: DUP3
00001720: GT
00001721: ISZERO
00001722: PUSH2 0x172e
00001725: JUMPI
00001726: PUSH2 0x172d
00001729: PUSH2 0x183a
0000172c: JUMP
0000172d: JUMPDEST
0000172e: JUMPDEST
0000172f: PUSH1 0x20
00001731: DUP3
00001732: MUL
00001733: SWAP1
00001734: POP
00001735: PUSH1 0x20
00001737: DUP2
00001738: ADD
00001739: SWAP1
0000173a: POP
0000173b: SWAP2
0000173c: SWAP1
0000173d: POP
0000173e: JUMP
0000173f: JUMPDEST
00001740: PUSH1 0x00
00001742: DUP2
00001743: SWAP1
00001744: POP
00001745: PUSH1 0x20
00001747: DUP3
00001748: ADD
00001749: SWAP1
0000174a: POP
0000174b: SWAP2
0000174c: SWAP1
0000174d: POP
0000174e: JUMP
0000174f: JUMPDEST
00001750: PUSH1 0x00
00001752: DUP2
00001753: MLOAD
00001754: SWAP1
00001755: POP
00001756: SWAP2
00001757: SWAP1
00001758: POP
00001759: JUMP
0000175a: JUMPDEST
0000175b: PUSH1 0x00
0000175d: PUSH1 0x20
0000175f: DUP3
00001760: ADD
00001761: SWAP1
00001762: POP
00001763: SWAP2
00001764: SWAP1
00001765: POP
00001766: JUMP
00001767: JUMPDEST
00001768: PUSH1 0x00
0000176a: DUP3
0000176b: DUP3
0000176c: MSTORE
0000176d: PUSH1 0x20
0000176f: DUP3
00001770: ADD
00001771: SWAP1
00001772: POP
00001773: SWAP3
00001774: SWAP2
00001775: POP
00001776: POP
00001777: JUMP
00001778: JUMPDEST
00001779: PUSH1 0x00
0000177b: DUP3
0000177c: DUP3
0000177d: MSTORE
0000177e: PUSH1 0x20
00001780: DUP3
00001781: ADD
00001782: SWAP1
00001783: POP
00001784: SWAP3
00001785: SWAP2
00001786: POP
00001787: POP
00001788: JUMP
00001789: JUMPDEST
0000178a: PUSH1 0x00
0000178c: PUSH2 0x1794
0000178f: DUP3
00001790: PUSH2 0x17cb
00001793: JUMP
00001794: JUMPDEST
00001795: SWAP1
00001796: POP
00001797: SWAP2
00001798: SWAP1
00001799: POP
0000179a: JUMP
0000179b: JUMPDEST
0000179c: PUSH1 0x00
0000179e: PUSH2 0x17a6
000017a1: DUP3
000017a2: PUSH2 0x17cb
000017a5: JUMP
000017a6: JUMPDEST
000017a7: SWAP1
000017a8: POP
000017a9: SWAP2
000017aa: SWAP1
000017ab: POP
000017ac: JUMP
000017ad: JUMPDEST
000017ae: PUSH1 0x00
000017b0: DUP2
000017b1: ISZERO
000017b2: ISZERO
000017b3: SWAP1
000017b4: POP
000017b5: SWAP2
000017b6: SWAP1
000017b7: POP
000017b8: JUMP
000017b9: JUMPDEST
000017ba: PUSH1 0x00
000017bc: PUSH2 0x17c4
000017bf: DUP3
000017c0: PUSH2 0x1789
000017c3: JUMP
000017c4: JUMPDEST
000017c5: SWAP1
000017c6: POP
000017c7: SWAP2
000017c8: SWAP1
000017c9: POP
000017ca: JUMP
000017cb: JUMPDEST
000017cc: PUSH1 0x00
000017ce: PUSH20 0xffffffffffffffffffffffffffffffffffffffff
000017e3: DUP3
000017e4: AND
000017e5: SWAP1
000017e6: POP
000017e7: SWAP2
000017e8: SWAP1
000017e9: POP
000017ea: JUMP
000017eb: JUMPDEST
000017ec: PUSH1 0x00
000017ee: PUSH3 0xffffff
000017f2: DUP3
000017f3: AND
000017f4: SWAP1
000017f5: POP
000017f6: SWAP2
000017f7: SWAP1
000017f8: POP
000017f9: JUMP
000017fa: JUMPDEST
000017fb: PUSH1 0x00
000017fd: DUP2
000017fe: SWAP1
000017ff: POP
00001800: SWAP2
00001801: SWAP1
00001802: POP
00001803: JUMP
00001804: JUMPDEST
00001805: PUSH1 0x00
00001807: PUSH2 0x180f
0000180a: DUP3
0000180b: PUSH2 0x1816
0000180e: JUMP
0000180f: JUMPDEST
00001810: SWAP1
00001811: POP
00001812: SWAP2
00001813: SWAP1
00001814: POP
00001815: JUMP
00001816: JUMPDEST
00001817: PUSH1 0x00
00001819: PUSH2 0x1821
0000181c: DUP3
0000181d: PUSH2 0x1828
00001820: JUMP
00001821: JUMPDEST
00001822: SWAP1
00001823: POP
00001824: SWAP2
00001825: SWAP1
00001826: POP
00001827: JUMP
00001828: JUMPDEST
00001829: PUSH1 0x00
0000182b: PUSH2 0x1833
0000182e: DUP3
0000182f: PUSH2 0x17cb
00001832: JUMP
00001833: JUMPDEST
00001834: SWAP1
00001835: POP
00001836: SWAP2
00001837: SWAP1
00001838: POP
00001839: JUMP
0000183a: JUMPDEST
0000183b: INVALID
0000183c: JUMPDEST
0000183d: PUSH2 0x1845
00001840: DUP2
00001841: PUSH2 0x1789
00001844: JUMP
00001845: JUMPDEST
00001846: DUP2
00001847: EQ
00001848: PUSH2 0x1850
0000184b: JUMPI
0000184c: PUSH1 0x00
0000184e: DUP1
0000184f: REVERT
00001850: JUMPDEST
00001851: POP
00001852: JUMP
00001853: JUMPDEST
00001854: PUSH2 0x185c
00001857: DUP2
00001858: PUSH2 0x17ad
0000185b: JUMP
0000185c: JUMPDEST
0000185d: DUP2
0000185e: EQ
0000185f: PUSH2 0x1867
00001862: JUMPI
00001863: PUSH1 0x00
00001865: DUP1
00001866: REVERT
00001867: JUMPDEST
00001868: POP
00001869: JUMP
0000186a: JUMPDEST
0000186b: PUSH2 0x1873
0000186e: DUP2
0000186f: PUSH2 0x17b9
00001872: JUMP
00001873: JUMPDEST
00001874: DUP2
00001875: EQ
00001876: PUSH2 0x187e
00001879: JUMPI
0000187a: PUSH1 0x00
0000187c: DUP1
0000187d: REVERT
0000187e: JUMPDEST
0000187f: POP
00001880: JUMP
00001881: JUMPDEST
00001882: PUSH2 0x188a
00001885: DUP2
00001886: PUSH2 0x17eb
00001889: JUMP
0000188a: JUMPDEST
0000188b: DUP2
0000188c: EQ
0000188d: PUSH2 0x1895
00001890: JUMPI
00001891: PUSH1 0x00
00001893: DUP1
00001894: REVERT
00001895: JUMPDEST
00001896: POP
00001897: JUMP
00001898: JUMPDEST
00001899: PUSH2 0x18a1
0000189c: DUP2
0000189d: PUSH2 0x17fa
000018a0: JUMP
000018a1: JUMPDEST
000018a2: DUP2
000018a3: EQ
000018a4: PUSH2 0x18ac
000018a7: JUMPI
000018a8: PUSH1 0x00
000018aa: DUP1
000018ab: REVERT
000018ac: JUMPDEST
000018ad: POP
000018ae: JUMP
000018af: INVALID
000018b0: LOG2
000018b1: PUSH5 0x6970667358
000018b7: UNKNOWN(0x22)
000018b8: SLT
000018b9: KECCAK256
000018ba: PUSH17 0x409932928d5805df80df0f0fb5ac3010a4
000018cc: PUSH7 0xfdc537c263afec
000018d4: SLOAD
000018d5: SWAP3
000018d6: UNKNOWN(0xC6)
000018d7: PUSH23